ea 0.6.141 → 0.6.142

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f4c5df621df87a4df4467c9cbe157f70ea49d0463a892ed7e57ada3550b1937
-  data.tar.gz: 69fdddf140a6553c565287ce099bfa7f3d70d6c981502c559368c2e9860e70db
+  metadata.gz: b51e9399fd02dbf1d891731d7a6cdcf754b1778efdbd3e3946479a02aa0761a2
+  data.tar.gz: 96c4a49164b75a78ac1a165bdd24f4a1a13e9e8199f84e1577fd111b7498b332
 SHA512:
-  metadata.gz: b5d5331f2954387a2ff2e9a93981964421958bac715ca436630b7aca0cefd00107973219d571a01e162692f6037cc695e52f94f04ab8808e899f1d08bd9fdba7
-  data.tar.gz: 6c63841163568dc3b95d840ed14f4d18fd95e7bfc51bf111a8d40b32ae0aec920cf530a99012690f642c6ef4709e6df6adca3917e634f61a5088891fbf99d14c
+  metadata.gz: 19e20b995ba1bcad98fb01f30b8cad1eec339994c57782f543e9b0014fe08f8bf4e2176ce4f5bea790e07c08bbe26f5745ee5609ec36ac1f1669e02e40f27973
+  data.tar.gz: ee051963f75748a2b32fb6021078146c76687d539e3f76cb52fd76281ef7abf6adeb355bfe48d528aa39244c400f5ea2a80064519f166c19098c3b5ecfef5dac

data/config/themes/default.yml

@@ -4,6 +4,13 @@ font:
   family:
   size:
   unit: px
+# Unthemed diagrams draw connector labels in Cambria 7pt, like the
+# themed ones (test B58D1A53 native; 0 of 220 published SVGs carry the
+# former Yu Gothic UI 13px fallback).
+label_font:
+  family: Cambria
+  size: 7
+  unit: pt
 text:
   color: "#000000"
   weight_normal: 400

data/lib/ea/model/diagram.rb

@@ -43,6 +43,12 @@ module Ea
         map "annotations", to: :annotations, render_empty: true
       end
 
+      # True for an object diagram. QEA stores "Object", the XMI adapter
+      # yields lowercase "object"; compare case-insensitively.
+      def object_diagram?
+        diagram_type.to_s.casecmp?("Object")
+      end
+
       # Parses style_ex into a Hash of flag => value. Returns empty
       # Hash when style_ex is nil/empty.
       #

data/lib/ea/qea/services/database_loader.rb

@@ -102,7 +102,6 @@ module Ea
         # @raise [Errno::ENOENT] if QEA file not found
         # @raise [SQLite3::Exception] if database access fails
         def load
-          # Connect but don't use with_connection - we need to keep it open
           @connection.connect unless @connection.connected?
           db = @connection.connection
 
@@ -117,6 +116,10 @@ module Ea
           end
 
           database.freeze
+        ensure
+          # All tables are in memory; nothing reads the connection after
+          # load, and an open handle locks the file on Windows.
+          @connection.close
         end
 
         # Load a single table

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

@@ -37,6 +37,7 @@ module Ea
           )
           mark_connector_proxies(doc)
           apply_tagged_values(doc)
+          apply_constraints(doc)
           apply_receptions(doc)
           apply_stereotypes(doc)
           resolve_type_names(doc)
@@ -93,6 +94,17 @@ module Ea
           end
         end
 
+        # Attach the extension's element constraints to their classifiers,
+        # as the QEA adapter does from t_objectconstraint.
+        def apply_constraints(doc)
+          grouped = ConstraintBuilder.new(xmi_path).grouped_by_element
+          return if grouped.empty?
+
+          doc.classifiers.each do |c|
+            c.constraints = grouped[c.id] if c.id && grouped[c.id]
+          end
+        end
+
         # Attach tagged values parsed from the <xmi:Extension><tags>
         # block to their owning classifiers and packages.
         def apply_tagged_values(doc)
@@ -130,6 +142,7 @@ module Ea
             (classifier.properties || []).each do |prop|
               prop.type_name = types.attribute_type(prop.id) ||
                                qualified_by_id[prop.type_ref] || prop.type_name
+              apply_attribute_stereotype(prop, types)
             end
             (classifier.operations || []).each do |op|
               resolve_operation_types(op, qualified_by_id, types)
@@ -137,6 +150,13 @@ module Ea
           end
         end
 
+        def apply_attribute_stereotype(prop, types)
+          stereotype = types.attribute_stereotype(prop.id)
+          return if stereotype.nil? || prop.stereotype_refs.to_a.any?
+
+          prop.stereotype_refs = [stereotype]
+        end
+
         def resolve_operation_types(operation, qualified_by_id, types)
           operation.return_type_name = types.return_type(operation.id) ||
                                        qualified_by_id[operation.return_type_name] ||

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Indexes the extension's `<connector>` nodes by `xmi:idref`. EA never
+      # repeats `<source>`, `<target>`, `<properties>` or `<xrefs>` inside one
+      # connector; if a hand-edited file does, the parse yields an Array where
+      # a single node is read, so the first occurrence is kept.
+      module ConnectorIndex
+        SINGLE_NODES = %i[source target properties xrefs].freeze
+
+        def self.build(root)
+          connectors = root.extension&.connectors&.connector || []
+          connectors.each_with_object({}) do |connector, index|
+            next unless connector.idref
+
+            SINGLE_NODES.each { |name| keep_first(connector, name) }
+            index[connector.idref] = connector
+          end
+        end
+
+        def self.keep_first(connector, name)
+          value = connector.public_send(name)
+          connector.public_send(:"#{name}=", value.first) if value.is_a?(Array)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts element constraints from the `<xmi:Extension><elements>`
+      # block (`<element><constraints><constraint/></constraints>`), the
+      # XMI image of t_objectconstraint. The xmi gem does not expose them,
+      # so the file is streamed once and grouped by owning element id.
+      class ConstraintBuilder
+        attr_reader :xmi_path
+
+        def initialize(xmi_path)
+          @xmi_path = xmi_path
+        end
+
+        # Returns Hash{element_id => Array<Ea::Model::Constraint>}
+        def grouped_by_element
+          return {} if xmi_path.nil?
+
+          @grouped_by_element ||= scan
+        end
+
+        private
+
+        def scan
+          @path = []
+          @owner = nil
+          @grouped = {}
+          @seen_owners = {}
+          @blocks_seen = {}
+          @skip_block = false
+          File.open(xmi_path) { |io| Nokogiri::XML::Reader(io).each { |node| visit(node) } }
+          @grouped
+        end
+
+        def visit(node)
+          case node.node_type
+          when Nokogiri::XML::Reader::TYPE_END_ELEMENT
+            @owner = nil if @path.pop == "element"
+          when Nokogiri::XML::Reader::TYPE_ELEMENT
+            enter(node)
+            @path.push(node.local_name) unless node.self_closing?
+          end
+        end
+
+        def enter(node)
+          if node.local_name == "element" && @path.last == "elements" && !node.self_closing?
+            @owner = first_block_owner(node.attribute("xmi:idref"))
+          elsif node.local_name == "constraints" && @owner && @path.last == "element"
+            @skip_block = @blocks_seen.key?(@owner)
+            @blocks_seen[@owner] = true
+          elsif node.local_name == "constraint" && @owner && !@skip_block && @path.last(2) == %w[element constraints]
+            (@grouped[@owner] ||= []) << constraint(node)
+          end
+        end
+
+        # A repeated `<element xmi:idref="X">` or `<constraints>` block would
+        # append X's constraints again, so only the first of each is read.
+        def first_block_owner(idref)
+          return nil if @seen_owners.key?(idref)
+
+          @seen_owners[idref] = true
+          idref
+        end
+
+        def constraint(node)
+          Ea::Model::Constraint.new(
+            id: IdNormalizer.synthetic_id(@owner, "constraint", @grouped[@owner].to_a.size.to_s),
+            name: node.attribute("name").to_s,
+            kind: node.attribute("type").to_s,
+            body: node.attribute("description").to_s,
+            status: node.attribute("status").to_s
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -415,12 +415,7 @@ module Ea
         end
 
         def connector_index
-          @connector_index ||= begin
-            conns = root.extension&.connectors&.connector || []
-            conns.each_with_object({}) do |c, acc|
-              acc[c.idref] = c if c.idref
-            end
-          end
+          @connector_index ||= ConnectorIndex.build(root)
         end
 
         def umldi_extractor

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

@@ -26,6 +26,7 @@ module Ea
 
         def initialize(document)
           @attributes = index(document, "attribute", "properties")
+          @attribute_stereotypes = index(document, "attribute", "stereotype", "stereotype")
           @returns = index(document, "operation", "type")
           @parameters = index(document, "parameter", "properties")
         end
@@ -34,6 +35,12 @@ module Ea
           @attributes[id]
         end
 
+        # Stereotype EA stores on the attribute row
+        # (<attribute><stereotype stereotype="voidable"/>).
+        def attribute_stereotype(id)
+          @attribute_stereotypes[id]
+        end
+
         def return_type(operation_id)
           @returns[operation_id]
         end
@@ -44,11 +51,11 @@ module Ea
 
         private
 
-        def index(document, owner, child)
+        def index(document, owner, child, attribute = "type")
           return {} unless document
 
           document.xpath(%(//*[local-name()="#{owner}"][@*[local-name()="idref"]])).each_with_object({}) do |node, acc|
-            type = node.at_xpath(%(*[local-name()="#{child}"]/@type))&.value
+            type = node.at_xpath(%(*[local-name()="#{child}"]/@#{attribute}))&.value
             idref = node.at_xpath("@*[local-name()='idref']").value
             acc[idref] = type unless type.nil? || type.empty?
           end

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

@@ -51,12 +51,21 @@ module Ea
           end
         end
 
+        # Extension connector type => handler; a nil-returning handler skips
+        # the connector (Dependency counts only when stereotyped import).
+        EXTENSION_IMPORTS = {
+          "Package" => :package_import_relationship,
+          "Nesting" => :package_import_relationship,
+          "Dependency" => :stereotyped_dependency_import
+        }.freeze
+
         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
+          handler = EXTENSION_IMPORTS[connector.properties&.ea_type]
+          handler && method(handler).call(id, connector)
+        end
+
+        def stereotyped_dependency_import(id, connector)
+          dependency_import_relationship(id, connector) if connector_stereotype(connector) == "import"
         end
 
         # EA exports elementImport outside packagedElement, so the model walk
@@ -73,6 +82,8 @@ module Ea
           connector&.xrefs&.value.to_s[CONNECTOR_STEREOTYPE]
         end
 
+        # Nesting connectors, like package imports, exist only in the
+        # extension; QEA models both as an Association between the ends.
         def package_import_relationship(id, connector)
           Ea::Model::Association.new(
             id: id,
@@ -245,12 +256,7 @@ module Ea
         end
 
         def connector_index
-          @connector_index ||= begin
-            connectors = root.extension&.connectors&.connector || []
-            connectors.each_with_object({}) do |connector, index|
-              index[connector.idref] = connector if connector.idref
-            end
-          end
+          @connector_index ||= ConnectorIndex.build(root)
         end
 
         def navigable?(id, endpoint)

data/lib/ea/sources/xmi.rb

@@ -25,11 +25,13 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :TagBuilder, "ea/sources/xmi/tag_builder"
+      autoload :ConstraintBuilder, "ea/sources/xmi/constraint_builder"
       autoload :LegendBuilder, "ea/sources/xmi/legend_builder"
       autoload :NoteBuilder, "ea/sources/xmi/note_builder"
       autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
       autoload :StoredRoute, "ea/sources/xmi/stored_route"
+      autoload :ConnectorIndex, "ea/sources/xmi/connector_index"
       autoload :ExtensionTypes, "ea/sources/xmi/extension_types"
       autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
       autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"

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

@@ -34,10 +34,12 @@ module Ea
             )
           end
 
+          # No element font size of its own: QEA marks it inherited, XMI
+          # records the missing size without the flag.
           def default_signal_header?(context)
             context.classifier.is_a?(Ea::Model::Signal) &&
               context.classifier.stereotype_refs.empty? &&
-              context.element.font_size_inherited == true &&
+              context.element.font_size.nil? &&
               context.element.font_family.nil? &&
               !context.element.font_bold && !context.element.font_italic
           end

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

@@ -45,7 +45,7 @@ module Ea
           end
 
           def object_diagram?(context)
-            context.diagram && context.diagram.diagram_type == "Object"
+            context.diagram&.object_diagram?
           end
 
           def hand_draw?(context)

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

@@ -41,7 +41,7 @@ module Ea
           end
 
           def object_diagram?(context)
-            context.diagram && context.diagram.diagram_type == "Object"
+            context.diagram&.object_diagram?
           end
           module_function :object_diagram?
 

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

@@ -632,12 +632,19 @@ module Ea
         # Dependency client→supplier (client_id/supplier_id),
         # Association source_id/target_id.
         def end_refs(rel)
-          case rel
-          when Ea::Model::Generalization then [rel.specific_id, rel.general_id]
-          when Ea::Model::Realization then [rel.realizing_id, rel.contract_id]
-          when Ea::Model::Dependency then [rel.client_id, rel.supplier_id]
-          else [rel.source_id, rel.target_id]
-          end
+          refs = case rel
+                 when Ea::Model::Generalization then [rel.specific_id, rel.general_id]
+                 when Ea::Model::Realization then [rel.realizing_id, rel.contract_id]
+                 when Ea::Model::Dependency then [rel.client_id, rel.supplier_id]
+                 else [rel.source_id, rel.target_id]
+                 end
+          refs.map { |ref| diagram_ref(ref) }
+        end
+
+        # A package is `EAPK_<guid>` in the XMI model but is placed on a
+        # diagram as `EAID_<guid>`; key its ends by the diagram spelling.
+        def diagram_ref(ref)
+          ref.is_a?(String) && ref.start_with?("EAPK_") ? "EAID_#{ref[5..]}" : ref
         end
 
         # Center-to-center ray clipped at both box outlines.

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

@@ -17,7 +17,7 @@ module Ea
         # origins the canvas on the drawn content like EA's native
         # unframed export; off, it keeps the framed 35/40 content origin.
         def initialize(diagram, model_index:, frame: false, document: nil,
-                       content_anchor: true, **_options)
+                       content_anchor: true)
           @diagram = diagram
           @model_index = model_index
           @frame = frame

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

@@ -116,7 +116,12 @@ module Ea
                                          lookup: lookup).to_s
               end
             else
-              ordered_properties(props, stored_order).flat_map do |prop|
+              # EMPIRICAL FIT (test B58D1A53, the only corpus class mixing
+              # stereotyped and plain attributes): EA draws the plain rows
+              # first, then the stereotyped ones in stored order.
+              plain, stereotyped = ordered_properties(props, stored_order)
+                                   .partition { |prop| property_stereotype(prop).nil? }
+              (plain + stereotyped).flat_map do |prop|
                 lines = []
                 stereotype = property_stereotype(prop)
                 lines << "«#{stereotype}»" if stereotype

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

@@ -206,6 +206,15 @@ module Ea
             content_bottom_y ? content_bottom_y + size + 5 : raw_attr_first_y
           end
 
+          # Bottom edge of the tags compartment: the last tag row plus one
+          # row of trailing space (204F4ACC: last baseline 83, EA bottom 95).
+          def tagged_values_bottom_y
+            return nil unless tagged_value_first_y
+
+            tagged_value_first_y +
+              (tagged_values_count.to_i + 1) * line_height(@size_unit == "pt" ? 6 : 4)
+          end
+
           # The lowest content edge among attributes, enum literals,
           # operations, and constraints — the anchor for trailing
           # compartments and the autosize height.

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

@@ -11,6 +11,7 @@ module Ea
         # the left edge from text-width approximation since SVG text
         # x= is the start position, not the center).
         class HeaderRenderer
+          OVERFLOW_INSET = 2
           HeaderLine = Struct.new(:text, :style, :x, :y, :text_length,
                                   :weight, :font_style, keyword_init: true)
 
@@ -83,7 +84,13 @@ module Ea
 
           # EA centers text by its INTEGER textLength and floors the
           # resulting x (verified exact against EA-published SVGs).
+          #
+          # EMPIRICAL FIT: a name wider than its box starts 2px inside the
+          # left edge instead of centring past it (simple 204F4ACC
+          # AcmeUmlEnumeration, 106 in a 90 box: x = box x + 2).
           def self.center_x_for(text_length, bounds)
+            return bounds.x + OVERFLOW_INSET if text_length > bounds.width
+
             (bounds.x + (bounds.width - text_length) / 2.0).floor
           end
           private_class_method :center_x_for

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

@@ -289,6 +289,7 @@ module Ea
               height: grown_bottom + compartment_bottom_padding(size, family, size_unit) - bounds.y
             )
           end
+          bounds = grow_for_tagged_values(bounds, geometry, element, classifier)
           RenderContext.new(
             element: element,
             bounds: bounds,
@@ -324,6 +325,21 @@ module Ea
           offset
         end
 
+        # A shown tags compartment that overflows the stored box grows
+        # it to the last tag row plus one row (204F4ACC AcmeUmlClass:
+        # QEA stores h70; EA draws h85, the XMI geometry already says 85).
+        # Fitted on that diagram only; boxes whose stored height already
+        # holds the tags are untouched.
+        def grow_for_tagged_values(bounds, geometry, element, classifier)
+          return bounds unless element.show_tagged_values && tagged_values_for(classifier).any?
+
+          tags_bottom = geometry.tagged_values_bottom_y
+          return bounds unless tags_bottom && tags_bottom > bounds.y + bounds.height
+
+          Ea::Model::Bounds.new(x: bounds.x, y: bounds.y, width: bounds.width,
+                                height: tags_bottom - bounds.y)
+        end
+
         def compartment_bottom_padding(size, family, size_unit)
           Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit) ? 7 : 8
         end
@@ -399,12 +415,18 @@ module Ea
         # that were +1: 0114FD24 uro::AbstractConstruction etc.; 20 of
         # 21 now exact, no other compared item moved). The tight ghost
         # variant has no corpus case and keeps the default offsets.
+        #
+        # An Enumeration with literals takes it too (EMPIRICAL FIT, test
+        # B58D1A53 Enumeration: divider 346 = name 339 + 7; the only Cambria 7pt
+        # enumeration with literals in the small corpora).
         def compact_header_offsets?(classifier, header_lines, size, **options)
-          classifier.is_a?(Ea::Model::Klass) &&
+          literals = options[:enum_literals_count]
+          kind_fits = (classifier.is_a?(Ea::Model::Klass) && literals.zero?) ||
+                      (classifier.is_a?(Ea::Model::Enumeration) && literals.positive?)
+          kind_fits &&
             Ea::Fonts::Metrics.compact_compartment_font?(size, family: options[:family], unit: options[:size_unit]) &&
             header_lines.dig(0, 1) != :italic_tight &&
-            options.values_at(:logical_height, :marker_count, :enum_literals_count,
-                              :divider_offset, :attr_first_offset) == [nil, 0, 0, 8, 7] &&
+            options.values_at(:logical_height, :marker_count, :divider_offset, :attr_first_offset) == [nil, 0, 8, 7] &&
             theme.compartments.header_line_offset == 6 && theme.compartments.attr_line_offset == 6
         end
 

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

@@ -134,7 +134,8 @@ module Ea
                          saved_ray_target_property_role(connector, heading, anchor, text_box, role) ||
                          target_diagonal_property_role(connector, heading, anchor, text_box, role) ||
                          target_vertical_role(connector, heading, anchor, text_box, role) ||
-                         target_rightward_role(heading, anchor, text_box, role) || text_pos
+                         target_rightward_role(heading, anchor, text_box, role) ||
+                         aligned_target_role(connector, heading, text_pos, text_box, role) || text_pos
               if horizontal_aligned_target_baseline?(connector, heading, text_box, role)
                 text_pos = [text_pos[0], seat_corner(anchor, text_box)[1] - 7]
               end
@@ -175,8 +176,11 @@ module Ea
             end
 
             role_bounds = umldi_bounds[end_kind == :source ? :source_role : :target_role]
+            # Unmoved lateral roles keep their measured seat: the saved UMLDI
+            # rectangle is stale for them (test B58D1A53 +role2 saved 24px low).
+            role_bounds = nil if PlainTargetSeat.unmoved_lateral_role?(connector, text_box)
             mult_bounds = umldi_bounds[end_kind == :source ? :source_multiplicity : :target_multiplicity]
-            text_pos = umldi_label_position(role_bounds) if role_bounds
+            text_pos = umldi_label_position(role_bounds, text_box) 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
@@ -196,6 +200,12 @@ module Ea
 
           private
 
+          # The width the renderer prints (real metrics, else its glyph estimate),
+          # so seats do not vanish for glyphs the metrics table lacks.
+          def seat_width(text)
+            TextRenderer.estimate_width(text, font_size, family: font_family)
+          end
+
           # 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.
@@ -294,12 +304,13 @@ module Ea
           end
 
           def plain_leftward_source_role(connector, direction, anchor, box, role)
-            return nil unless direction == :left && seat_font? && cambria_box?(box) && !role_empty?(role)
+            return nil unless direction == :left && seat_font? && !role_empty?(role)
+            return nil unless box && cambria_box?(box.merge("alignment" => 1))
             return nil unless connector_source_dest_stereotype(connector, :source).to_s.empty?
 
             PlainSourceSeat.position(
               connector: connector, anchor: anchor, box: box,
-              width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+              width: seat_width(role)
             )
           end
 
@@ -725,6 +736,23 @@ module Ea
             [anchor[0] + 8, anchor[1] - 7]
           end
 
+          # Stored ALN=2 role boxes sit outside their corner; see
+          # PlainTargetSeat.aligned_position.
+          def aligned_target_role(connector, heading, text_pos, box, role)
+            PlainTargetSeat.aligned_role(
+              connector: connector, heading: heading, text_pos: text_pos,
+              box: box, role: role, font_eligible: aligned_seat_font?,
+              width: seat_width(role.to_s),
+              target_stereotype: connector_source_dest_stereotype(connector, :target)
+            )
+          end
+
+          # 7pt regular Cambria, the only face the ALN=2 samples were taken in.
+          def aligned_seat_font?
+            seat_font? && font_family.to_s.casecmp("Cambria").zero? &&
+              font_weight == 400 && font_style == "normal"
+          end
+
           def target_vertical_role(connector, heading, anchor, box, role)
             return nil unless heading && heading[0].zero? && !heading[1].zero?
 
@@ -1045,8 +1073,11 @@ module Ea
                        position[1] - font_pixel_size.ceil + height]
           end
 
-          def umldi_label_position(bounds)
-            [bounds[:x], bounds[:y] + font_pixel_size.ceil]
+          # EA draws an ALN=2 role 1px right of its saved UMLDI bounds
+          # (basic: 9 roles in 8 diagrams, all exactly +1).
+          def umldi_label_position(bounds, box = nil)
+            inset = box && box["alignment"] == 2 ? 1 : 0
+            [bounds[:x] + inset, bounds[:y] + font_pixel_size.ceil]
           end
 
           def umldi_stereotype_position(bounds, role, stereo, text_box)
@@ -1134,12 +1165,13 @@ module Ea
             property unless property && opposite_role_property?(association, end_kind, property)
           end
 
-          # A UML attribute belongs to the classifier opposite its role.
-          # Do not draw that same role again at its anonymous owner end.
+          # A UML attribute belongs to the classifier opposite its role: a
+          # property named after the opposite end's role, and not after this
+          # end's own, is that end's label. Do not draw it again here.
           def opposite_role_property?(association, end_kind, property)
             own = end_kind == :source ? association.source_role_name : association.target_role_name
             other = end_kind == :source ? association.target_role_name : association.source_role_name
-            role_empty?(own) && other == property.name
+            other == property.name && own != property.name
           end
 
           def placed_classifier_id(association, end_kind)

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

@@ -49,6 +49,35 @@ module Ea
             render_text(mx, my, content)
           end
 
+          # Returns the name-direction triangle `<polygon>` for a connector
+          # whose stored LMT box carries DIR=1, or nil. EA seats it beside
+          # the name, pointing along the source-to-target direction at the
+          # midpoint. Measured only on Direction="Unspecified" links (all 10
+          # basic.qea DIR=1 links; no DIR=1 link with another Direction exists
+          # in basic, test, simple, ArcGIS or PLATEAU), so other directions
+          # draw no triangle until a native sample shows their form. Right/down
+          # geometry is measured on basic.qea's native SVGs (2AAB709F,
+          # 4DBDAB9E, 4F421236, D2FA55D3 and 6E95B74E: tip 16px past the
+          # name, 10px long, 6px wide; below the name for a vertical leg).
+          # Left/up are the mirrored extrapolation: no corpus case.
+          def direction_marker(connector, points)
+            return nil unless midpoint_content(connector)
+
+            box = stored_name_box(connector, points)
+            return nil unless box && box["direction"] == 1
+            return nil unless connector.direction == "Unspecified"
+
+            # A name with an unmeasured glyph is drawn at the default seat, so
+            # the triangle follows where the name is drawn, by its printed width.
+            x, y = stored_name_position(connector, points) || label_position(connector, points)
+            width = TextRenderer.estimate_width(midpoint_content(connector), font_size, family: font_family)
+
+            tri = direction_triangle(x, y, width, travel(points))
+            coords = tri.flat_map { |px, py| [translate_x(px), translate_y(py)] }
+            %(<polygon points="#{coords.map { |v| Canvas.coord(v) }.join(" ")}" ) +
+              %(shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+          end
+
           # Returns the formatted «stereotype» string or nil. Used
           # by Label::Registry to dispatch end-label vs midpoint.
           def stereotype_label(connector)
@@ -194,6 +223,43 @@ module Ea
               target[1] < last_bend[1]
           end
 
+          # Unit travel direction [dx, dy] at the midpoint: dominant axis only.
+          def travel(points)
+            mid_idx = points.size / 2
+            from, to = if points.size.odd?
+                         [points[mid_idx - 1], points[mid_idx + 1]]
+                       else
+                         [points[mid_idx - 1], points[mid_idx]]
+                       end
+            dx = to[0] - from[0]
+            dy = to[1] - from[1]
+            return [dx.negative? ? -1 : 1, 0] if dx.abs >= dy.abs
+
+            [0, dy.negative? ? -1 : 1]
+          end
+
+          def direction_triangle(x, y, width, travel)
+            dx, dy = travel
+            if dy.zero?
+              tip_x = dx.positive? ? x + width + 16 : x - 16
+              base_x = tip_x - (dx * 10)
+              [[tip_x, y - 4], [base_x, y - 7], [base_x, y - 1]]
+            else
+              center_x = x + (width / 2.0).floor
+              tip_y = dy.positive? ? y + 13 : y - 21
+              base_y = tip_y - (dy * 10)
+              [[center_x, tip_y], [center_x - 3, base_y], [center_x + 3, base_y]]
+            end
+          end
+
+          def translate_x(value)
+            canvas ? canvas.translate_x(value) : value
+          end
+
+          def translate_y(value)
+            canvas ? canvas.translate_y(value) : value
+          end
+
           def midpoint(points)
             mid_idx = points.size / 2
             if points.size.odd?

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

@@ -7,10 +7,33 @@ module Ea
         # Plain leftward roles end before the stored corner, mirroring
         # the 3px gutter and baseline of the rightward role seat.
         module PlainSourceSeat
+          # EMPIRICAL FIT, stored 13px role boxes moved left of a leftward
+          # straight source on mode 3, width 0: ALN=0 ends 3px before the
+          # corner (basic D351FC34, F32E5AFE roleTwo, Association), ALN=2
+          # 2px before it (basic 6D0349D5 role b, Aggregation); both sit
+          # 7px above the corner like the Aggregation case below.
+          # Only cy=13 boxes are measured: every negative-OX LLT box with ALN 0 or
+          # 2 in basic, test, simple, ArcGIS and PLATEAU has cy=13 (cy=14 occurs
+          # only with ALN=1), so the ALN=2 target seat's 13-or-14 tolerance is
+          # not extended to the source.
+          STORED_INSETS = { 0 => 3, 2 => 2 }.freeze
+
           def self.position(connector:, anchor:, box:, width:)
-            return nil unless width && eligible_connector?(connector) && moved_role_box?(box)
+            return nil unless width
+
+            inset = stored_inset(connector, box)
+            inset = 3 if inset.nil? && eligible_connector?(connector) && moved_role_box?(box)
+            return nil unless inset
+
+            [anchor[0] + box["ox"].to_i - width - inset, anchor[1] + box["oy"].to_i - 7]
+          end
+
+          def self.stored_inset(connector, box)
+            return nil unless %w[Association Aggregation].include?(connector.connector_type)
+            return nil unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
+            return nil unless box["cy"] == 13 && box["ox"].to_i.negative?
 
-            [anchor[0] + box["ox"].to_i - width - 3, anchor[1] + box["oy"].to_i - 7]
+            STORED_INSETS[box["alignment"]]
           end
 
           def self.eligible_connector?(connector)

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

@@ -7,11 +7,74 @@ module Ea
         # Plain leftward target roles end three pixels before the anchor.
         module PlainTargetSeat
           def self.position(connector:, anchor:, box:, width:)
-            return nil unless width && eligible_connector?(connector) && zero_role_box?(box)
+            return nil unless width
+            return nil unless (eligible_connector?(connector) && zero_role_box?(box)) ||
+                              (lateral_connector?(connector) && lateral_zero_box?(box))
 
             [anchor[0] - width - 3, anchor[1] - 7]
           end
 
+          # EMPIRICAL FIT: an unmoved ALN=0 13px role on a width-0 derived
+          # lateral-horizontal association seats like the plain target above
+          # (test B58D1A53 +role2, the only such leftward target).
+          def self.unmoved_lateral_role?(connector, box)
+            !box.nil? && lateral_connector?(connector) && lateral_zero_box?(box)
+          end
+
+          def self.lateral_connector?(connector)
+            style = connector.style.to_h
+            connector.connector_type == "Association" &&
+              style.values_at(:mode, :lwidth, :tree) == %w[3 0 LH] &&
+              (style[:derived_lateral_line] || style[:umldi_route]) == true
+          end
+
+          def self.lateral_zero_box?(box)
+            box.values_at("alignment", "cy") == [0, 13] &&
+              box.values_at("ox", "oy").map(&:to_i) == [0, 0]
+          end
+
+          # EMPIRICAL FIT: a stored ALN=2 role box on a horizontal
+          # arrival keeps its mirrored corner, text_pos, and is drawn
+          # outside it: a leftward arrival (OX < 0) ends 2px short of the
+          # corner (7 samples in basic: 6E95B74E, 4F421236, 2AAB709F,
+          # 4DBDAB9E, D2FA55D3 x2, width 30); a rightward arrival (OX > 0)
+          # starts 4px past it (basic D351FC34, F32E5AFE roleOne, width 41).
+          # Eligibility and placement of a stored ALN=2 target role: a plain
+          # Association, mode 3 / width 0 stored ray, a single-line (CY 13/14)
+          # unstyled ALN=2 box, no target stereotype, in the eligible font.
+          def self.aligned_role(connector:, heading:, text_pos:, box:, role:, width:,
+                                font_eligible:, target_stereotype:)
+            return nil unless font_eligible && !role.to_s.empty? && target_stereotype.to_s.empty?
+            return nil unless aligned_connector?(connector) && aligned_box?(box)
+
+            aligned_position(heading: heading, text_pos: text_pos, box: box, width: width)
+          end
+
+          def self.aligned_connector?(connector)
+            style = connector.style.to_h
+            connector.connector_type == "Association" &&
+              style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] && style[:stored_association_ray]
+          end
+
+          def self.aligned_box?(box)
+            return false unless box && box["alignment"] == 2 && [13, 14].include?(box["cy"])
+            return false unless box["ox"] && box["oy"] && [nil, -1].include?(box["color"])
+
+            box["rotation"].to_i.zero? && box["direction"].to_i.zero? &&
+              box.values_at("hidden", "bold", "italic", "underline").none?
+          end
+
+          def self.aligned_position(heading:, text_pos:, box:, width:)
+            return nil unless width && text_pos && heading && heading[1].zero?
+
+            ox = box["ox"].to_i
+            if heading[0].negative? && ox.negative?
+              [text_pos[0] - width - 2, text_pos[1]]
+            elsif heading[0].positive? && ox.positive?
+              [text_pos[0] + 4, text_pos[1]]
+            end
+          end
+
           def self.eligible_connector?(connector)
             connector.connector_type == "Association" &&
               connector.style.to_h.values_at(:mode, :lwidth, :tree, :plain_target_seat) == ["3", "2", nil, true]

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

@@ -36,11 +36,29 @@ module Ea
           @divider_y_by_ref = divider_y_by_ref
         end
 
+        TEXT_GROUP = "stroke-width:1;stroke-linecap:round;stroke-linejoin:%<join>s; " \
+                     "fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
+        MARKER_GROUP = "stroke-width:1;stroke-linecap:round;stroke-linejoin:round; " \
+                       "fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+
+        # A name-direction triangle is a filled shape painted between the
+        # text runs; EA closes the text group around it and keeps the
+        # round-join pen for the text that follows.
+        DirectionMarker = Struct.new(:svg)
+
         def render
-          texts = visible_connectors.flat_map { |c| texts_for(c) }
-          return "" if texts.empty?
+          items = visible_connectors.flat_map { |c| texts_for(c) }
+          return "" if items.empty?
 
-          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{texts.join("\n")}\n</g>)
+          join = "bevel"
+          items.slice_when { |a, b| a.is_a?(DirectionMarker) || b.is_a?(DirectionMarker) }.map do |run|
+            if run.first.is_a?(DirectionMarker)
+              join = "round"
+              %(<g style="#{MARKER_GROUP}">\n  #{run.first.svg}\n</g>)
+            else
+              %(<g style="#{format(TEXT_GROUP, join: join)}">\n#{run.join("\n")}\n</g>)
+            end
+          end.join("\n")
         end
 
         # Right edge of the stored end-label boxes (model coordinates)
@@ -51,8 +69,12 @@ module Ea
 
         private
 
+        # Labels follow the connector paint order (as the XMI diagram order
+        # already does), so QEA and XMI emit the same text sequence. Against
+        # native on PLATEAU this is a wash (79/188 exact sequences either way);
+        # it is verified on basic.qea's native SVGs.
         def visible_connectors
-          (diagram.connectors || []).select(&:renderable?)
+          PaintOrder.connectors(diagram).select(&:renderable?)
         end
 
         def texts_for(connector)
@@ -63,22 +85,18 @@ module Ea
           points = label_points(connector)
           return [] if points.size < 2
 
-          texts = []
-
           # Midpoint label: stereotype «import», or relationship
           # Name ("Association A"). Renders at the path midpoint.
           mid_text = midpoint_renderer.text_for(connector, points)
-          texts << mid_text if mid_text
+          return [mid_text, direction_marker(connector, points)].compact unless registry.end_label?(connector)
 
           # End-labels: role name + «property» + multiplicity at
           # positioned LLT/LRT boxes. Only for associations without
           # a midpoint stereotype (stereotyped associations route
-          # to midpoint only).
-          if registry.end_label?(connector)
-            end_label_texts(connector, points).each { |t| texts << t }
-          end
-
-          texts
+          # to midpoint only). EA paints the source end, then the
+          # midpoint label, then the target end (basic.xmi native SVGs).
+          source_texts, target_texts = end_label_texts(connector, points)
+          [*source_texts, mid_text, direction_marker(connector, points), *target_texts].compact
         end
 
         def end_label_texts(connector, points)
@@ -94,24 +112,23 @@ module Ea
           src_tb, src_mb = stored_src || unstored_label_boxes(points, :source, stored_labels, connector)
           tgt_tb, tgt_mb = stored_tgt || unstored_label_boxes(points, :target, stored_labels, connector)
 
-          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 || 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,
-                             anchor: target_pt, connector: connector,
-                             end_kind: :target, tree: tree && tree[:target],
-                             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,
-                             umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :target)).each { |t| texts << t }
-          texts
+          source_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 || 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))
+          target_texts = end_renderer.texts(text_box: tgt_tb,
+                                            mult_box: tgt_mb,
+                                            anchor: target_pt, connector: connector,
+                                            end_kind: :target, tree: tree && tree[:target],
+                                            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,
+                                            umldi_bounds: available_umldi_bounds(umldi_bounds, boxes, :target))
+          [source_texts, target_texts]
         end
 
         # Role bounds the XMI builder keeps belong to this connector's own
@@ -348,6 +365,11 @@ module Ea
           )
         end
 
+        def direction_marker(connector, points)
+          svg = midpoint_renderer.direction_marker(connector, points)
+          DirectionMarker.new(svg) if svg
+        end
+
         def midpoint_renderer
           @midpoint_renderer ||= Label::MidpointLabel.new(
             canvas: canvas,

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

@@ -270,7 +270,7 @@ module Ea
         end
 
         def object_diagram?
-          diagram.diagram_type == "Object"
+          diagram.object_diagram?
         end
 
         # Rounded [x, y] of the marker's tip (anchor) in canvas

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.141"
+  VERSION = "0.6.142"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.141
+  version: 0.6.142
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -851,6 +851,8 @@ files:
 - lib/ea/sources/xmi/adapter.rb
 - lib/ea/sources/xmi/annotation_builder.rb
 - lib/ea/sources/xmi/classifier_builder.rb
+- lib/ea/sources/xmi/connector_index.rb
+- lib/ea/sources/xmi/constraint_builder.rb
 - lib/ea/sources/xmi/diagram_builder.rb
 - lib/ea/sources/xmi/diagram_builder/association_class_metadata.rb
 - lib/ea/sources/xmi/diagram_builder/connector_metadata.rb