ea 0.6.136 → 0.6.138

data/lib/ea/sources/xmi/relationship_builder.rb

@@ -45,12 +45,30 @@ module Ea
         def package_import_relationships(built)
           built_ids = built.to_set(&:id)
           connector_index.filter_map do |id, connector|
-            next if built_ids.include?(id) || connector.properties&.ea_type != "Package"
+            next if built_ids.include?(id)
 
-            package_import_relationship(id, connector)
+            extension_import_relationship(id, connector)
           end
         end
 
+        def extension_import_relationship(id, connector)
+          case connector.properties&.ea_type
+          when "Package" then package_import_relationship(id, connector)
+          when "Dependency"
+            dependency_import_relationship(id, connector) if connector_stereotype(connector) == "import"
+          end
+        end
+
+        # EA exports elementImport outside packagedElement, so the model walk
+        # misses it; the extension retains the importing/imported endpoints.
+        def dependency_import_relationship(id, connector)
+          Ea::Model::Dependency.new(
+            id: id, stereotype: "import",
+            client_id: connector.source&.idref,
+            supplier_id: connector.target&.idref
+          )
+        end
+
         def connector_stereotype(connector)
           connector&.xrefs&.value.to_s[CONNECTOR_STEREOTYPE]
         end

data/lib/ea/sources/xmi/stored_route.rb

@@ -26,8 +26,174 @@ module Ea
           finish(points, link, connector, source, target, bends, ports, offsets, edge)
         end
 
+        # Direct custom-line associations and aggregations retain ray origins as
+        # well as their computed boundary ports, just as the QEA builder does.
+        def ray_metadata(model, link:, bounds:, offsets:, edge:)
+          return {} unless direct_association_ray?(model, bounds, offsets)
+
+          source, target = bounds.values_at(:source, :target)
+          geom = ray_geometry(offsets, edge)
+          return {} unless saved_association_ray?(model, link, source, target, geom)
+
+          ray_points(source, target, offsets, geom)
+        end
+
+        def phantom_waypoints(source, target)
+          [bounds_edge_point(source, target), bounds_edge_point(target, source)]
+        end
+
+        # Apply QEA's saved Association stages after the initial route, including
+        # UMLDI fallback. A single stored corner and an empty-path stored ray
+        # carry mathematical origins that the generic facing-edge route loses.
+        def association_route(model, link:, bounds:, offsets:, edge:)
+          overlap = umldi_association_metadata(model, link, bounds, offsets, edge)
+          return overlap unless overlap.empty?
+
+          partial = partial_port_metadata(model, link, bounds, offsets, edge)
+          return partial unless partial.empty?
+
+          return {} unless stored_association_candidate?(model, bounds)
+
+          candidate = association_model(model, bounds, offsets)
+          initial = candidate.waypoints
+          association_stored_ray(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} if candidate.waypoints.equal?(initial)
+
+          association_metadata(candidate)
+        end
+
         private
 
+        def umldi_association_metadata(model, link, bounds, offsets, edge)
+          overlap = umldi_overlap_metadata(model, link, bounds, offsets, edge)
+          return overlap unless overlap.empty?
+
+          umldi_stored_ray_metadata(model, link, bounds, offsets, edge)
+        end
+
+        # UMLDI owns the route and ports. Classify a thin saved ray only when
+        # its origins pass the shared unstroked-box checks; XMI has no QEA
+        # database from which to infer a wider element outline.
+        def umldi_stored_ray_metadata(model, link, bounds, offsets, edge)
+          return {} unless umldi_thin_ray_candidate?(model, bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          return {} unless association_ray_candidate?(candidate, link)
+          return {} unless association_ray_origins(*bounds.values_at(:source, :target),
+                                                   ray_geometry(offsets, edge), "0")
+
+          { style: model.style.to_h.merge(stored_association_ray: true, association_ray_outline: true) }
+        end
+
+        def umldi_thin_ray_candidate?(model, bounds, offsets)
+          model.style[:umldi_route] && model.style[:lwidth] == "0" &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # UMLDI owns the drawn route; retain QEA's overlap origins only for
+        # interpreting the stored relative end labels against that route.
+        def umldi_overlap_metadata(model, link, bounds, offsets, edge)
+          return {} unless umldi_overlap_candidate?(model, bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          overlap_ray_origins(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} unless candidate.style[:overlap_ray]
+
+          { source_anchor: candidate.source_anchor, target_anchor: candidate.target_anchor,
+            has_geometry_offsets: true, style: candidate.style.to_h }
+        end
+
+        def umldi_overlap_candidate?(model, bounds, offsets)
+          model.style.to_h.values_at(:umldi_route, :mode, :lwidth) == [true, "2", "0"] &&
+            model.waypoints.size == 2 && bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # A zero-offset end has no explicit port, but QEA still carries both
+        # mathematical origins for the emitter's final boundary redocking.
+        def partial_port_metadata(model, link, bounds, offsets, edge)
+          return {} unless partial_port_candidate?(model, link, bounds, offsets)
+
+          source, target = bounds.values_at(:source, :target)
+          return {} unless saved_association_ray?(model, link, source, target, ray_geometry(offsets, edge))
+
+          association_ends(bounds, offsets).merge(has_geometry_offsets: true)
+        end
+
+        def partial_port_candidate?(model, link, bounds, offsets)
+          model.connector_type == "Aggregation" && !model.style[:umldi_route] && !link.path.to_s.empty? &&
+            direct_association_ray?(model, bounds, offsets) &&
+            offsets.values.count { |offset| offset.all?(&:zero?) } == 1
+        end
+
+        def stored_association_candidate?(model, bounds)
+          model.connector_type == "Association" && bounds.values.all? &&
+            association_ray_style?(model.style.to_h) && model.style[:lwidth] == "2"
+        end
+
+        def association_metadata(model)
+          fields = %i[waypoints source_anchor target_anchor source_port target_port has_geometry_offsets]
+          fields.to_h { |name| [name, model.public_send(name)] }.merge(
+            style: model.style.to_h.reject { |key, _| key == :umldi_route }
+          )
+        end
+
+        def association_model(model, bounds, offsets)
+          Ea::Model::DiagramConnector.new(
+            { connector_type: model.connector_type, style: model.style.to_h.dup, waypoints: model.waypoints,
+              has_geometry_offsets: !offsets[:source][0].nil? }.merge(association_ends(bounds, offsets))
+          )
+        end
+
+        def association_ends(bounds, offsets)
+          %i[source target].each_with_object({}) do |kind, result|
+            box = bounds.fetch(kind)
+            offset = offsets.fetch(kind)
+            port = port_for(box, offset)
+            result["#{kind}_port".to_sym] = point_for(port) if port
+            result["#{kind}_anchor".to_sym] = association_anchor(box, offset)
+          end
+        end
+
+        def association_anchor(box, offset)
+          Ea::Model::Point.new(x: box.x + box.width / 2 + offset[0].to_i,
+                               y: box.y + box.height / 2 + offset[1].to_i)
+        end
+
+        def stored_ray_boxes(_link, bounds)
+          bounds.values_at(:source, :target)
+        end
+
+        def direct_association_ray?(model, bounds, offsets)
+          %w[Association Aggregation].include?(model.connector_type) && model.waypoints.size == 2 &&
+            model.style.to_h.values_at(:mode, :lwidth, :tree) == ["1", "2", nil] &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        def ray_geometry(offsets, edge)
+          { sx: offsets[:source][0], sy: offsets[:source][1],
+            ex: offsets[:target][0], ey: offsets[:target][1], edge: edge }
+        end
+
+        def saved_association_ray?(model, link, source, target, geom)
+          (!geom[:sy].zero? || !geom[:ey].zero?) &&
+            stored_ray_gap?(source, target, "1", geom[:edge]) &&
+            stored_association_path?(model, link, source, target, geom)
+        end
+
+        def ray_points(source, target, offsets, geom)
+          ports = [port_for(source, offsets[:source]), port_for(target, offsets[:target])]
+          return {} unless ports.all?
+
+          { source_port: point_for(ports.first), target_port: point_for(ports.last),
+            source_anchor: stored_ray_origin(source, geom[:sx], geom[:sy]),
+            target_anchor: stored_ray_origin(target, geom[:ex], geom[:ey]),
+            has_geometry_offsets: true }
+        end
+
+        def point_for(pair)
+          Ea::Model::Point.new(x: pair[0], y: pair[1])
+        end
+
         # Placements here are already Ea::Model::Bounds.
         def bounds_from_rect(bounds)
           bounds
@@ -64,10 +230,37 @@ module Ea
 
         def bent_points(src, bends, tgt, link, connector, source, target)
           points = [src, *bends, tgt]
-          redock_parent_above(points, link, source, target) if connector.connector_type == "Generalization"
+          if connector.connector_type == "Generalization"
+            preserve_side_entry = authored_lateral_side_entry?(points, bends, link, source, target)
+            redock_parent_above(points, link, source, target)
+            points[-1] = [points[-1][0], points[1][1]] if preserve_side_entry
+          end
           points
         end
 
+        # A single LH tree bend can be the authored side-entry level itself.
+        # Parent-above redocking normally moves a Generalization to the target
+        # bottom, which destroys that horizontal leg and disagrees with QEA.
+        def authored_lateral_side_entry?(points, bends, link, source, target)
+          return false unless bends.one? && points.size == 3 && lateral_side_entry_style?(link) &&
+                              target.y + target.height <= source.y
+
+          level_on_target_side?(points[1], target)
+        end
+
+        def lateral_side_entry_style?(link)
+          style = Qea::DiagramStyleParser.parse(link.style)
+          style[:mode] == "3" && style[:tree] == "LH" && style[:lwidth] == "2"
+        end
+
+        def within_width?(x, bounds)
+          x.between?(bounds.x, bounds.x + bounds.width)
+        end
+
+        def level_on_target_side?(bend, target)
+          bend[1].between?(target.y, target.y + target.height) && !within_width?(bend[0], target)
+        end
+
         def finish(points, link, connector, source, target, bends, ports, offsets, edge)
           tree_route = stored_tree_route(points, link, connector, source, target, ports)
           if tree_route

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

@@ -94,8 +94,9 @@ module Ea
           end
 
           def content_x_offset(theme, size, size_unit, family)
-            # EA uses the attribute row point-size increment for literal names.
-            offset = theme.attribute_spec.content_x_offset || 26
+            # EA seats literal names at the attribute-name content x, with the
+            # attribute row point-size increment.
+            offset = theme.attribute_content_x_offset || 26
             offset += 2 * (size - 7) if size_unit == "pt"
             offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
             offset

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

@@ -19,11 +19,12 @@ module Ea
         # self-loop, an authoritative UMLDI route, or no drawn bounds for either end).
         def pairs_for(connector, diagram, model_index, bounds_map)
           return nil unless bounds_map
-          return nil if connector.style.to_h[:umldi_route] == true
 
           tether = association_class_pairs(connector, bounds_map)
           return tether if tether
 
+          return nil if connector.style.to_h[:umldi_route] == true
+
           points = waypoint_pairs(connector)
           lateral = lateral_tree?(connector, points)
           trunk = trunk_tree?(connector, points)

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

@@ -19,10 +19,10 @@ module Ea
           def self.render(tagged_values, bounds:, first_y:, family:, size:, fill: "#000000",
                           size_unit: "px", logical_height: nil)
             line_h = line_height(size, family, size_unit, logical_height)
-            text_blocks = [build_text(bounds.x + centered_x_offset(bounds, family, size, size_unit, logical_height),
+            text_blocks = [build_text(header_x(bounds, family, size, size_unit, logical_height),
                                       first_y, HEADER_TEXT, family, size, fill,
                                       style: "italic", size_unit: size_unit, logical_height: logical_height)]
-            tagged_values.each_with_index do |tv, idx|
+            ordered_values(tagged_values).each_with_index do |tv, idx|
               text_blocks << build_text(bounds.x + LINE_X_OFFSET, first_y + ((idx + 1) * line_h),
                                         "#{tv.key} = #{tv.value}", family, size, fill,
                                         size_unit: size_unit, logical_height: logical_height)
@@ -30,6 +30,11 @@ module Ea
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
+          def self.ordered_values(tagged_values)
+            tagged_values.sort_by { |tv| tv.key.to_s.downcase }
+          end
+          private_class_method :ordered_values
+
           def self.build_text(x, y, content, family, size, fill, style: "normal",
                               size_unit: "px", logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
@@ -48,7 +53,7 @@ module Ea
           private_class_method :line_height
 
           # Center the "tags" header text within the bounds width.
-          def self.centered_x_offset(bounds, family, size, size_unit, logical_height)
+          def self.header_x(bounds, family, size, size_unit, logical_height)
             # QEA point captions center on the same integer width emitted in SVG.
             # Retain the legacy pixel API's placement.
             text_width = if size_unit == "pt"
@@ -60,9 +65,9 @@ module Ea
                            HEADER_TEXT.length * (size / 2)
                          end
             centered = ((bounds.width - text_width) / 2.0).floor
-            [HEADER_X_OFFSET, centered].max
+            bounds.x + [HEADER_X_OFFSET, centered].max
           end
-          private_class_method :centered_x_offset
+          private_class_method :header_x
         end
       end
     end

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

@@ -22,9 +22,11 @@ module Ea
           SEAT_FONT_SIZE = 7
           SEAT_X_INSET = 3
           SEAT_STEREOTYPE_GAP = 12
-          # EA keeps an upward property seat's left edge at diagram x >= 3;
-          # the stereotype line moves with the role. Measured only for the
-          # default Cambria 7pt boxed cluster.
+          # EA keeps an end-label role's left edge at diagram x >= 3; the
+          # stereotype line moves with the role. Measured on the Plateau
+          # v5.1 export: of 776 saved end labels, the only three whose
+          # UMLDI bounds start left of 3 (47E4600F, CB34B578, 159E9DA0) are
+          # drawn at x = 3, and no label is drawn left of it.
           MIN_ROLE_X = 3
 
           attr_reader :canvas, :model_index, :document, :theme,
@@ -61,12 +63,13 @@ module Ea
           #                   fallback
           def texts(text_box:, mult_box:, anchor:, connector:, end_kind:,
                     tree: false, heading: nil, stored_labels: false, bend: nil, source_bounds: nil,
-                    target_face: nil)
+                    target_face: nil, umldi_bounds: {})
             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
+              if stored_labels || connector.style.to_h[:explicit_end_roles] ||
+                 connector.style.to_h[:phantom_outline] == true
                 return [] if role_empty?(other_role) && mult_empty?(other_mult)
 
                 return own_stereotype_only(text_box, anchor, connector,
@@ -104,7 +107,7 @@ module Ea
                          plain_vertical_role(connector, direction, anchor, text_box, role) ||
                          source_property_seat(connector, direction, anchor, text_box, role) ||
                          plain_upward_seat(connector, direction, anchor, text_box, role) ||
-                         role_seat(direction, anchor, text_box, role) || text_pos
+                         role_seat(connector, direction, anchor, text_box, role) || text_pos
               mult_pos = directional_multiplicity(direction, anchor, mult_box, mult) ||
                          horizontal_tree_multiplicity(connector, direction, anchor, mult_box, mult) ||
                          mult_seat(direction, anchor, mult_box) || mult_pos
@@ -149,12 +152,53 @@ module Ea
               text_pos, mult_pos = stair_positions if stair_positions
             end
 
+            role_bounds = umldi_bounds[end_kind == :source ? :source_role : :target_role]
+            mult_bounds = umldi_bounds[end_kind == :source ? :source_multiplicity : :target_multiplicity]
+            text_pos = umldi_label_position(role_bounds) if role_bounds
+            centering = role_bounds ? bounds_role_centering(connector, end_kind, role, stereo, text_box) : 0
+            text_pos = [text_pos[0] + centering, text_pos[1]] if centering.positive?
+            mult_pos = umldi_label_position(mult_bounds) if mult_bounds
+            if stereo && role_bounds
+              stereo_pos = umldi_stereotype_position(role_bounds, role, stereo, text_box)
+              stereo_pos = [role_bounds[:x], stereo_pos[1]] if centering.positive?
+            end
+
+            if text_pos && !role_empty?(role) && min_role_x_cluster?(connector, end_kind, heading, text_box)
+              text_pos, stereo_pos = clamp_role_x(text_pos, stereo_pos)
+            end
+
             build_texts(role:, mult:, standalone:,
-                        text_pos:, mult_pos:, stereo:, text_box:)
+                        text_pos:, mult_pos:, stereo:, text_box:, stereo_pos:)
           end
 
           private
 
+          # Measured only for default Cambria 7pt Property roles on a vertical
+          # leg rising from the end; other fonts, boxes and legs keep their
+          # unclamped seats.
+          def min_role_x_cluster?(connector, end_kind, heading, text_box)
+            rising_vertical?(heading) && plain_seat_font? &&
+              cambria_box?(text_box) && property_label?(connector, end_kind)
+          end
+
+          def rising_vertical?(heading)
+            heading && heading[0].zero? && heading[1].negative?
+          end
+
+          def plain_seat_font?
+            seat_font? && font_weight == 400 && font_style == "normal"
+          end
+
+          # Shift the role and its stereotype line together when the role
+          # would start left of EA's minimum label x.
+          def clamp_role_x(text_pos, stereo_pos)
+            shift = MIN_ROLE_X - text_pos[0]
+            return [text_pos, stereo_pos] unless shift.positive?
+
+            [[text_pos[0] + shift, text_pos[1]],
+             stereo_pos && [stereo_pos[0] + shift, stereo_pos[1]]]
+          end
+
           # ALN2 single-line target roles retain their horizontal placement
           # and use the saved corner's baseline on a straight stored ray.
           def horizontal_aligned_target_baseline?(connector, heading, box, role)
@@ -190,8 +234,11 @@ module Ea
             [x - width - SEAT_X_INSET, y - 7] if width
           end
 
+          # UMLDI routes carry the inferred saved-ray flag; their stored LRT
+          # box keeps the plain target seat.
           def moved_plain_target_ray?(connector, box)
-            saved_target_ray?(connector) && box.values_at("alignment", "cy") == [1, 16] &&
+            saved_target_ray?(connector) && connector.style.to_h[:umldi_route] != true &&
+              box.values_at("alignment", "cy") == [1, 16] &&
               !stored_offsets_zero?(box)
           end
 
@@ -318,15 +365,33 @@ module Ea
             nil
           end
 
+          # Saved bounds seat a source Property role at the stereotype's left
+          # edge. A centred stored box (ALN=1), or a phantom's synthesized box
+          # without alignment, centres the shorter role over it; a
+          # left-aligned box keeps both lines on that edge.
+          def bounds_role_centering(connector, end_kind, role, stereo, text_box)
+            return 0 unless end_kind == :source && stereo && seat_font?
+            return 0 unless centred_bounds_box?(connector, text_box)
+            return 0 unless property_label?(connector, :source)
+
+            -[stereotype_offset(role, stereo, { "alignment" => 1 }), 0].min
+          end
+
+          # Phantom outlines have no saved diagram link, so their boxes are
+          # synthesized and EA draws its centred default label.
+          def centred_bounds_box?(connector, text_box)
+            connector.style.to_h[:phantom_outline] == true || text_box.to_h["alignment"] == 1
+          end
+
           # Role text on a rightward leg is left-aligned at the corner,
           # 7px above it.
-          def role_seat(direction, anchor, box, role)
+          def role_seat(connector, direction, anchor, box, role)
             return nil unless direction == :right
             return nil if box.nil? || role_empty?(role)
             return nil unless default_presentation?(box)
 
             x, y = seat_corner(anchor, box)
-            [x + SEAT_X_INSET, y - 7]
+            [x + SEAT_X_INSET + source_property_centering(connector, direction, box, role), y - 7]
           end
 
           # Property-role clusters use a direction-specific horizontal seat;
@@ -348,12 +413,26 @@ module Ea
           # Center a short role above the wider stereotype without moving
           # the directional cluster's left edge. Other boxes keep their seat.
           def source_property_centering(connector, direction, box, role)
-            return 0 unless %i[left down].include?(direction)
+            return 0 unless centered_property_box?(connector, direction, box)
+
+            property_role_centering(connector, :source, box, role)
+          end
+
+          def property_role_centering(connector, end_kind, box, role)
             return 0 unless seat_font? && font_weight == 400 && font_style == "normal"
-            return 0 unless box.values_at("cy", "alignment") == [35, 1]
+            return 0 unless property_label?(connector, end_kind)
+
+            stereo = "«#{connector_source_dest_stereotype(connector, end_kind)}»"
+            -[stereotype_offset(role, stereo, box.merge("alignment" => 1)), 0].min
+          end
 
-            stereo = "«#{connector_source_dest_stereotype(connector, :source)}»"
-            -[stereotype_offset(role, stereo, box), 0].min
+          # Measured box heights: left/down Property clusters store CY 35,
+          # right-seat clusters CY 31. Phantom outlines leaving down carry a
+          # synthesized zero box that centers the same way.
+          def centered_property_box?(connector, direction, box)
+            cy = { left: 35, down: 35, right: 31 }[direction]
+            (cy && box.values_at("cy", "alignment") == [cy, 1]) ||
+              (direction == :down && phantom_property_box?(connector, direction, box))
           end
 
           def source_property_seat?(connector, direction, box)
@@ -367,7 +446,7 @@ module Ea
           # Their default Property cluster uses the directional seat with a
           # centered stereotype; persisted or moved boxes keep their own seat.
           def phantom_property_box?(connector, direction, box)
-            %i[up left].include?(direction) && seat_font? && cambria_box?(box) &&
+            %i[up left down].include?(direction) && seat_font? && cambria_box?(box) &&
               box["alignment"].nil? && stored_offsets_zero?(box) &&
               connector.style.to_h[:phantom_outline] == true &&
               property_label?(connector, :source)
@@ -522,7 +601,7 @@ module Ea
 
             x, y = seat_corner(anchor, box)
             inset, = property_role_offsets(:down)
-            [x - inset - width, y - 7]
+            [x - inset - width + property_role_centering(connector, :target, box, role), y - 7]
           end
 
           def upward_target_property?(connector, heading)
@@ -665,7 +744,8 @@ module Ea
 
           def downward_source_route?(style, box)
             [orthogonal_stub_route?(style), lateral_horizontal_route?(style), mode_two_route?(style),
-             downward_property_route?(style), persisted_width_zero_down_box?(box, style)].any?
+             downward_property_route?(style), persisted_width_zero_down_box?(box, style),
+             centered_width_zero_down_box?(box, style)].any?
           end
 
           def persisted_width_zero_down_box?(box, style)
@@ -673,6 +753,11 @@ module Ea
               style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
           end
 
+          def centered_width_zero_down_box?(box, style)
+            box["alignment"] == 1 && stored_offsets_zero?(box) &&
+              style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
+          end
+
           # Mode 3, width 2 on the horizontal lateral tree.
           def lateral_horizontal_route?(style)
             style.values_at(:mode, :lwidth, :tree) == %w[3 2 LH]
@@ -820,13 +905,14 @@ module Ea
           end
 
           def build_texts(role:, mult:, standalone:, text_pos:, mult_pos:,
-                          stereo:, text_box:)
+                          stereo:, text_box:, stereo_pos: nil)
             if role && !role.empty? && text_pos
               x, y = text_pos
               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(text_box), stereo)
+                stereo_x, stereo_y = stereo_pos || [x + stereotype_offset(role, stereo, text_box),
+                                                    y + property_y_offset(text_box)]
+                texts << text_at(stereo_x, stereo_y, stereo)
               end
               if mult && !mult.empty? && mult_pos
                 texts << text_at(*mult_pos, mult)
@@ -839,6 +925,19 @@ module Ea
             end
           end
 
+          def umldi_label_position(bounds)
+            [bounds[:x], bounds[:y] + font_pixel_size.ceil]
+          end
+
+          def umldi_stereotype_position(bounds, role, stereo, text_box)
+            [bounds[:x] + stereotype_offset(role, stereo, text_box),
+             bounds[:y] + font_pixel_size.ceil + (font_pixel_size.ceil + 2)]
+          end
+
+          def font_pixel_size
+            font_unit == "pt" ? font_size * 4.0 / 3 : font_size
+          end
+
           def stereotype_offset(role, stereo, text_box)
             return 0 unless text_box && text_box["alignment"] == 1
 

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

@@ -83,7 +83,8 @@ module Ea
 
           stored_src = end_boxes(boxes, :llt, :llb)
           stored_tgt = end_boxes(boxes, :lrt, :lrb)
-          stored_labels = !(stored_src.nil? && stored_tgt.nil?)
+          umldi_bounds = connector.umldi_label_bounds || {}
+          stored_labels = !(stored_src.nil? && stored_tgt.nil?) || !umldi_bounds.empty?
           src_tb, src_mb = stored_src || unstored_label_boxes(points, :source, stored_labels)
           tgt_tb, tgt_mb = stored_tgt || unstored_label_boxes(points, :target, stored_labels)
 
@@ -93,6 +94,7 @@ module Ea
                              end_kind: :source, tree: tree && tree[:source],
                              heading: (stored_src || stored_labels) && source_heading(connector, points),
                              stored_labels: stored_labels,
+                             umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :source),
                              source_bounds: source_dock_bounds(connector)).each { |t| texts << t }
           end_renderer.texts(text_box: tgt_tb,
                              mult_box: tgt_mb,
@@ -101,10 +103,21 @@ module Ea
                              bend: Label::TargetBendSeat.reference(points),
                              heading: (stored_tgt || stored_labels) && target_heading(connector, points),
                              target_face: target_dock_heading(connector, target_pt, target_heading(connector, points)),
-                             stored_labels: stored_labels).each { |t| texts << t }
+                             stored_labels: stored_labels,
+                             umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :target)).each { |t| texts << t }
           texts
         end
 
+        # Role bounds the XMI builder keeps belong to this connector's own
+        # memberEnd and win over a stored role box; a stored multiplicity box
+        # wins over multiplicity bounds.
+        def available_umldi_bounds(bounds, label_boxes, end_kind)
+          mult_key = end_kind == :source ? :llb : :lrb
+          result = bounds.dup
+          result.delete(end_kind == :source ? :source_multiplicity : :target_multiplicity) if label_boxes.key?(mult_key)
+          result
+        end
+
         # A connector that stores label boxes for only one end seats the
         # other end's labels at its anchor, like a stored zero offset.
         def unstored_label_boxes(points, end_kind, stored_labels)

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

@@ -52,11 +52,16 @@ module Ea
         # feature compartment — even one whose rows are all hidden
         # by visibility flags (10E3E08A: CodeList with 3 attributes
         # toggled off still renders the divider over an empty body;
-        # only feature-less elements omit it).
+        # only feature-less elements omit it). Association-end
+        # properties are not EA attributes (QEA keeps them as connector
+        # roles; the XMI reads them as ownedAttribute), so a class whose
+        # only properties are association ends has no feature compartment
+        # and no divider (A59065AF urf::Administration).
         def hidden_features_present?
           return false unless classifier.respond_to?(:properties)
 
-          classifier.properties.any? || classifier.operations.any?
+          classifier.properties.any? { |property| !property.association_id } ||
+            classifier.operations.any?
         end
       end
     end

data/lib/ea/theme/definition.rb

@@ -138,8 +138,8 @@ module Ea
         @label_font_size_unit || font_size_unit
       end
 
-      # Attribute cells have a different inherited seat from enum literals,
-      # which continue to consume the legacy attribute_spec default.
+      # Content x of attribute and enum-literal names; a theme's own
+      # attribute_spec overrides the inherited seat.
       def attribute_content_x_offset
         @attribute_spec_override ? attribute_spec.content_x_offset : 22
       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.136"
+  VERSION = "0.6.138"
 end