ea 0.6.134 → 0.6.136

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3320f99ef26e1639eaa88eba212fe6620cc7c25b5337681431bf1ba991c384c1
-  data.tar.gz: 3a72b42b4c3dd40b4254ec74684b3e74a25e6f35f1efc85ec8e7bb1fc59f113b
+  metadata.gz: 121e254bdf4c232789483be3fc0de9f65e0b70a89c34009db6421d9dcae1337d
+  data.tar.gz: 1f11075a36fe5f7208b264f4f10e409230afe184101157ba41a3bf05fd57efb6
 SHA512:
-  metadata.gz: 8ce24e25f39d48215c9dcbe03b8c86a932ffd310d64f228e6e5603448814faf84fc023f1a07dae736f4dabb926970b86d1bd478e51d640366462c1765a643796
-  data.tar.gz: 19a7f0f2e20a3985c32de44288755f7daa7f5f35e41908c6491a9ada31562059c20826e75d7482ad494b8e9c2e15ab32f5635f1801607c359f7fcdc6a455ea50
+  metadata.gz: f924fea92342d3525a5fb5ea6b1b8c0167afc5f709d1c373a52b178a263efa29c9adc8bf690c4fba1073053a2f75c5888abbd509dcd187c39a57a0ab4c089286
+  data.tar.gz: 5c558dcefad07838fd403fa8eae5a9e7bf00e802348de364d28adb692e02bb76a6de2909139570431bb96a364955c276a5a356b05ba5107ce6906f0aa03315a5

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

@@ -35,6 +35,7 @@ module Ea
             instance_specifications: instance_specifications,
             diagrams: diagrams
           )
+          mark_connector_proxies(doc)
           apply_tagged_values(doc)
           apply_receptions(doc)
           apply_stereotypes(doc)
@@ -44,6 +45,23 @@ module Ea
 
         private
 
+        # EA serializes connector anchors as UML class stubs. Keep their
+        # identity and geometry while distinguishing their graphical role.
+        def mark_connector_proxies(doc)
+          proxy_ids = connector_proxy_ids
+          return if proxy_ids.empty?
+
+          doc.diagrams.flat_map(&:elements).each do |element|
+            element.style["connector_proxy"] = true if proxy_ids.include?(element.model_element_ref)
+          end
+        end
+
+        def connector_proxy_ids
+          (root.extension&.elements&.element || []).filter_map do |element|
+            IdNormalizer.from_xmi_id(element.idref) if element.type == "uml:ProxyConnector"
+          end
+        end
+
         def apply_receptions(doc)
           grouped = ReceptionBuilder.new(xmi_path).grouped_by_owner
           doc.classifiers.each do |classifier|
@@ -99,10 +117,9 @@ module Ea
           end
         end
 
-        # Replaces each type reference with its in-model qualified
-        # name; references that are not classifiers (primitive hrefs,
-        # EA placeholder idrefs) take the type name EA stores in the
-        # extension block.
+        # Replaces each type reference with the type name EA stores in
+        # the extension block; references the extension does not name
+        # fall back to the classifier's in-model qualified name.
         def resolve_type_names(doc)
           qualified_by_id = doc.classifiers.each_with_object({}) do |c, acc|
             acc[c.id] = c.qualified_name if c.id && c.qualified_name
@@ -111,8 +128,8 @@ module Ea
 
           doc.classifiers.each do |classifier|
             (classifier.properties || []).each do |prop|
-              prop.type_name = qualified_by_id[prop.type_ref] ||
-                               types.attribute_type(prop.id) || prop.type_name
+              prop.type_name = types.attribute_type(prop.id) ||
+                               qualified_by_id[prop.type_ref] || prop.type_name
             end
             (classifier.operations || []).each do |op|
               resolve_operation_types(op, qualified_by_id, types)
@@ -121,12 +138,12 @@ module Ea
         end
 
         def resolve_operation_types(operation, qualified_by_id, types)
-          operation.return_type_name = qualified_by_id[operation.return_type_name] ||
-                                       types.return_type(operation.id) ||
+          operation.return_type_name = types.return_type(operation.id) ||
+                                       qualified_by_id[operation.return_type_name] ||
                                        operation.return_type_name
           operation.parameters.each do |param|
-            param.type_name = qualified_by_id[param.type_name] ||
-                              types.parameter_type(param.id) || param.type_name
+            param.type_name = types.parameter_type(param.id) ||
+                              qualified_by_id[param.type_name] || param.type_name
           end
         end
 

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

@@ -16,41 +16,49 @@ module Ea
 
         def build_all
           classifiers = []
-          walk(root.model) do |element, parent_pkg|
-            next unless TypeClassifierMap.classifier_type?(element.type)
+          root.model.packaged_element.each do |top|
+            walk(top, top.type == "uml:Package" ? top : nil) do |element, parent_pkg, owner_class|
+              next unless TypeClassifierMap.classifier_type?(element.type)
 
-            classifiers << build_one(element, parent_pkg)
+              classifiers << build_one(element, parent_pkg, owner_class)
+            end
           end
           classifiers
         end
 
-        def build_one(element, containing_package)
+        def build_one(element, containing_package, owner_class = nil)
           klass = TypeClassifierMap.class_for(element.type)
-          args = common_args(element, containing_package)
+          args = common_args(element, containing_package, owner_class)
           args.merge!(enumeration_args(element)) if klass == Ea::Model::Enumeration
           klass.new(**args)
         end
 
         private
 
-        # Depth-first walk of the packaged_element tree. Yields each
-        # element with its containing uml:Package (or nil at the
-        # model root).
-        def walk(element, parent_pkg = nil, &block)
-          yield element, parent_pkg if block
+        # Depth-first walk of the packaged_element and nestedClassifier
+        # trees. Yields each element with its containing uml:Package
+        # (nil at the model root) and the uml:Class that nests it
+        # (nil unless it is a nestedClassifier of a class).
+        def walk(element, parent_pkg = nil, owner_class = nil, &block)
+          yield element, parent_pkg, owner_class if block
           element.packaged_element.each do |inner|
             new_parent = inner.type == "uml:Package" ? inner : parent_pkg
-            walk(inner, new_parent, &block)
+            walk(inner, new_parent, nil, &block)
+          end
+          element.nested_classifier.each do |inner|
+            walk(inner, parent_pkg, element, &block)
           end
         end
 
-        def common_args(element, containing_package)
+        def common_args(element, containing_package, owner_class)
           id = IdNormalizer.from_xmi_id(element.id)
+          nested_parent = owner_class&.name
           {
             id: id,
             name: element.name,
             package_id: containing_package && IdNormalizer.from_xmi_id(containing_package.id),
-            qualified_name: qualified_name(element, containing_package),
+            nested_parent_name: nested_parent,
+            qualified_name: qualified_name(element, containing_package, nested_parent),
             is_abstract: boolean(element.is_abstract),
             visibility: element.visibility,
             properties: PropertyBuilder.new.build_all_for(element),
@@ -83,10 +91,12 @@ module Ea
         end
 
         # A name that already carries a namespace prefix
-        # (e.g. "gml:CodeType") is the qualified name as saved.
-        def qualified_name(element, containing_package)
+        # (e.g. "gml:CodeType") is the qualified name as saved; a
+        # nested classifier is prefixed with its owner class.
+        def qualified_name(element, containing_package, nested_parent)
           name = element.name.to_s
           return name if name.include?(":")
+          return "#{nested_parent}::#{name}" if nested_parent
 
           pkg_name = containing_package&.name
           pkg_name ? "#{pkg_name}::#{name}" : name

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        # The XMI gem omits role stereotypes. Stream the saved connector
+        # records once, without retaining another full XML document.
+        class ConnectorMetadata
+          def initialize(xmi_path)
+            @xmi_path = xmi_path
+          end
+
+          def for(connector)
+            {
+              source_stereotype: role_stereotypes.dig(connector.idref, :source),
+              target_stereotype: role_stereotypes.dig(connector.idref, :target),
+              is_substitutable: false_substitutability?(connector.xrefs&.value.to_s)
+            }
+          end
+
+          private
+
+          def false_substitutability?(xrefs)
+            xrefs.scan(/\$XREFPROP=(.*?)\$ENDXREF;/m).any? do |match|
+              record = match.first
+              next false unless record.include?("$NAM=CustomProperties$NAM;") &&
+                                record.include?("$TYP=connector property$TYP;")
+
+              values = record.scan(/@PROP=(.*?)@ENDPROP;/m).filter_map do |property|
+                substitutability_value(property.first)
+              end
+              !values.empty? && !values.include?("-1")
+            end
+          end
+
+          def substitutability_value(property)
+            return unless property.include?("@NAME=isSubstitutable@ENDNAME;") &&
+                          property.include?("@TYPE=Boolean@ENDTYPE;")
+
+            property[/@VALU=(.*?)@ENDVALU;/m, 1]
+          end
+
+          def role_stereotypes
+            @role_stereotypes ||= read_role_stereotypes
+          end
+
+          def read_role_stereotypes
+            return {} unless @xmi_path
+
+            File.open(@xmi_path) do |file|
+              Nokogiri::XML::Reader(file).each_with_object({}) do |node, roles|
+                next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT && node.local_name == "connector"
+
+                read_connector_roles(node, roles)
+              end
+            end
+          end
+
+          def read_connector_roles(node, roles)
+            connector = Nokogiri::XML(node.outer_xml).root
+            id = connector.at_xpath("@*[local-name()='idref']")&.value
+            return unless id
+
+            roles[id] = %i[source target].to_h do |side|
+              value = connector.at_xpath("./*[local-name()='#{side}']/*[local-name()='role']/@stereotype")&.value
+              [side, value]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        # The XMI gem exposes placement fonts but drops object styleex.
+        # Read saved defaults once, then let each placement override them.
+        class FontSettings
+          def initialize(xmi_path)
+            @xmi_path = xmi_path
+          end
+
+          def for(placed)
+            style = placed.style
+            defaults = object_styles.fetch(placed.subject, {})
+            placement = ExtensionStyleParser.split_pairs(style.raw.to_s)
+            raw_size = saved_size(placement) || saved_size(defaults)
+            {
+              family: presence(style.font_family) || defaults["font"],
+              size: style.font_size || ExtensionStyleParser.scale_font_size(raw_size),
+              logical_height: logical_height(raw_size)
+            }
+          end
+
+          private
+
+          def presence(value)
+            value unless value.nil? || value.empty?
+          end
+
+          def saved_size(style)
+            value = style["fontsz"]
+            value if ExtensionStyleParser.int(value)&.nonzero?
+          end
+
+          def logical_height(value)
+            tenths = ExtensionStyleParser.int(value)
+            tenths * 96 / 720 if tenths
+          end
+
+          def object_styles
+            @object_styles ||= saved_objects.each_with_object({}) do |element, styles|
+              id = element.at_xpath("@*[local-name()='idref']")&.value
+              style = element.at_xpath("./*[local-name()='style']/@styleex")&.value
+              styles[id] = ExtensionStyleParser.split_pairs(style) if id && style
+            end
+          end
+
+          def saved_objects
+            return [] unless @xmi_path
+
+            doc = Nokogiri::XML(File.read(@xmi_path))
+            doc.xpath("//*[local-name()='Extension']/*[local-name()='elements']/*[local-name()='element']")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        # Keep graphical spelling provenance separate from semantic stereotype names.
+        class StereotypeProfiles
+          def initialize(root)
+            @elements = root.extension&.elements&.element.to_a.to_h { |element| [element.idref, element] }
+          end
+
+          def for(subject)
+            element = @elements[subject]
+            name = element&.properties&.stereotype
+            return {} if name.to_s.empty?
+
+            fqname = matching_profile(element.xrefs&.value.to_s, name)
+            fqname ? { stereotype_fqname: fqname } : {}
+          end
+
+          private
+
+          def matching_profile(value, name)
+            value.split("@STEREO;").drop(1).each do |block|
+              description = "@STEREO;#{block.partition("@ENDSTEREO;").first}@ENDSTEREO;"
+              application = Qea::Xref::Parser.parse(description).stereotype
+              return application.fqname if application.name == name
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,9 @@ module Ea
       # SOID/EOID, EDGE, label boxes) when present. Falls back to
       # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
+        autoload :ConnectorMetadata, "ea/sources/xmi/diagram_builder/connector_metadata"
+        autoload :FontSettings, "ea/sources/xmi/diagram_builder/font_settings"
+        autoload :StereotypeProfiles, "ea/sources/xmi/diagram_builder/stereotype_profiles"
         autoload :UmldiEdges, "ea/sources/xmi/diagram_builder/umldi_edges"
 
         attr_reader :root, :xmi_path
@@ -58,6 +61,8 @@ module Ea
             show_notes: style_ex_for(ext_diagram).to_s.include?("ShowNotes=1"),
             show_package_contents: style_flag?(ext_diagram, "PackageContents"),
             show_foreign: style_flag?(ext_diagram, "HighlightForeign"),
+            show_parents: !style_flag?(ext_diagram, "HideParents"),
+            hand_draw: style_flag?(ext_diagram, "HandDraw"),
             elements: build_elements(placed_elements, id, umldi_keywords),
             connectors: build_connectors(placed_connectors,
                                           placed_elements, id),
@@ -113,6 +118,7 @@ module Ea
           geom = placed.geometry
           style = placed.style
           bounds = build_bounds(geom.left, geom.top, geom.right, geom.bottom)
+          font = (@font_settings ||= FontSettings.new(xmi_path)).for(placed)
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic_id(owner_id, "elem", placed.subject),
             diagram_id: owner_id,
@@ -122,8 +128,10 @@ module Ea
             background_color: style.background_color,
             line_color: style.line_color,
             line_width: style.line_width,
-            font_family: style.font_family,
-            font_size: style.font_size,
+            font_family: font[:family],
+            font_size: font[:size],
+            font_logical_height: font[:logical_height],
+            font_size_inherited: ExtensionStyleParser.split_pairs(style.raw.to_s)["fontsz"] == "0",
             font_bold: style.bold,
             font_italic: style.italic,
             font_underline: style.underline,
@@ -132,7 +140,7 @@ module Ea
             z_order: placed.seqno,
             duid: style.duid,
             umldi_keyword: umldi_keywords[placed.subject],
-            style: {}
+            style: (@stereotype_profiles ||= StereotypeProfiles.new(root)).for(placed.subject)
           )
         end
 
@@ -177,6 +185,9 @@ module Ea
             target_edge: geom.edge,
             connector_type: ext_meta[:ea_type],
             direction: ext_meta[:direction],
+            source_stereotype: ext_meta[:source_stereotype],
+            target_stereotype: ext_meta[:target_stereotype],
+            is_substitutable: ext_meta.fetch(:is_substitutable, false),
             waypoints: route[:waypoints],
             style: route[:style],
             line_color: style.color,
@@ -194,7 +205,11 @@ module Ea
           {
             ea_type: props&.ea_type,
             direction: props&.direction
-          }
+          }.merge(connector_metadata.for(connector))
+        end
+
+        def connector_metadata
+          @connector_metadata ||= ConnectorMetadata.new(xmi_path)
         end
 
         def connector_index

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

@@ -60,12 +60,16 @@ module Ea
         end
 
         def child_classifier_ids(packaged_element)
-          packaged_element.packaged_element
-                          .filter_map do |pe|
-                            next unless TypeClassifierMap.classifier_type?(pe.type)
+          packaged_element.packaged_element.flat_map do |element|
+            classifier_ids(element)
+          end
+        end
+
+        def classifier_ids(element)
+          return [] unless TypeClassifierMap.classifier_type?(element.type)
 
-                            IdNormalizer.from_xmi_id(pe.id)
-                          end
+          [IdNormalizer.from_xmi_id(element.id),
+           *element.nested_classifier.flat_map { |inner| classifier_ids(inner) }].compact
         end
       end
     end

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

@@ -24,11 +24,11 @@ module Ea
 
         def build_all
           relationships = []
-          walk(root.model) do |element|
-            next unless RelationshipTypeMap.relationship_type?(element.type)
-
-            rel = build_one(element)
-            relationships << rel if rel
+          root.model.packaged_element.each do |top|
+            walk(top) do |element|
+              relationships << build_one(element) if RelationshipTypeMap.relationship_type?(element.type)
+              relationships.concat(owned_generalizations(element))
+            end
           end
           relationships + package_import_relationships(relationships)
         end
@@ -69,6 +69,17 @@ module Ea
         def walk(element, &block)
           yield element if block
           element.packaged_element.each { |inner| walk(inner, &block) }
+          element.nested_classifier.each { |inner| walk(inner, &block) }
+        end
+
+        def owned_generalizations(element)
+          element.generalization.map do |generalization|
+            Ea::Model::Generalization.new(
+              id: IdNormalizer.from_xmi_id(generalization.id),
+              specific_id: IdNormalizer.from_xmi_id(element.id),
+              general_id: IdNormalizer.from_xmi_id(generalization.general)
+            )
+          end
         end
 
         def common_args(element)

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

@@ -40,14 +40,24 @@ module Ea
 
         private
 
-        # Text of the shape's UMLKeywordLabel child; name labels and
-        # other labelled children never contribute a keyword.
+        # EA can save both a built-in keyword and a custom stereotype label.
+        # Prefer the label matching the element's saved stereotype, if present.
         def keyword_text(shape)
-          label = shape.xpath("./ownedElement[@*[local-name()=\"type\"]=\"umldi:UMLKeywordLabel\"]").first
+          labels = shape.xpath("./ownedElement[@*[local-name()=\"type\"]=\"umldi:UMLKeywordLabel\"]")
+          stereotype = stereotypes_by_element[shape["modelElement"]]
+          label = labels.find { |candidate| stereotype && candidate["text"] == stereotype } || labels.first
           text = label && label["text"]
           text unless text.nil? || text.empty?
         end
 
+        def stereotypes_by_element
+          @stereotypes_by_element ||= doc.xpath("//*[local-name()=\"Extension\"]/elements/element")
+                                         .each_with_object({}) do |element, result|
+                                           stereotype = element.at_xpath("./properties")&.[]("stereotype")
+                                           result[element["idref"] || element["xmi:idref"]] = stereotype if stereotype
+                                         end
+        end
+
         def doc
           @doc ||= Nokogiri::XML(File.read(xmi_path))
         end

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

@@ -11,7 +11,9 @@ module Ea
         # boundaries to fit the element bounds.
         module NoteText
           X_PADDING = 5
+          HAND_DRAW_X_PADDING = 10
           Y_FIRST_OFFSET = 15
+          HAND_DRAW_Y_FIRST_OFFSET = 11
           LINE_OFFSET = 13
           CHAR_WIDTH_FACTOR = 0.55
 
@@ -24,23 +26,30 @@ module Ea
             notes = note_bodies(context.classifier)
             return nil if notes.empty?
 
-            first_y = context.geometry.attr_first_y + Y_FIRST_OFFSET
+            x_padding, y_offset = note_offsets(context)
+            first_y = context.geometry.attr_first_y + y_offset
             bounds = context.bounds
             fill = context.theme.attribute_text_color
-            usable_width = bounds.width - (X_PADDING * 2)
+            usable_width = bounds.width - (x_padding * 2)
             max_chars = (usable_width / (context.size * CHAR_WIDTH_FACTOR)).floor
 
             texts = []
             y = first_y
             notes.each do |body|
               wrapped_lines(body, max_chars).each do |line|
-                texts << build_text(line, bounds.x + X_PADDING, y, context, fill)
+                texts << build_text(line, bounds.x + x_padding, y, context, fill)
                 y += LINE_OFFSET
               end
             end
             wrap_group(texts.join("\n"), fill)
           end
 
+          # Native hand-drawn classifiers use a wider documentation inset.
+          def note_offsets(context)
+            context.diagram.hand_draw ? [HAND_DRAW_X_PADDING, HAND_DRAW_Y_FIRST_OFFSET] : [X_PADDING, Y_FIRST_OFFSET]
+          end
+          module_function :note_offsets
+
           def show_notes?(context)
             context.diagram && context.diagram.show_notes
           end
@@ -67,7 +76,9 @@ module Ea
               elsif (current + " " + word).length <= max_chars
                 current = "#{current} #{word}"
               else
-                lines << current
+                # EA retains the consumed word separator on a wrapped
+                # documentation row, including it in SVG textLength.
+                lines << "#{current} "
                 current = word
               end
             end

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

@@ -90,8 +90,8 @@ module Ea
           end
 
           # Builds attribute display lines from classifier properties,
-          # hiding properties that are navigable association ends
-          # (those are rendered as connector lines).
+          # hiding association-end properties even when their connectors
+          # are not drawn on the diagram.
           #
           # When a property carries a stereotype (e.g. «voidable»),
           # EA renders the stereotype label as a separate line above
@@ -171,19 +171,11 @@ module Ea
           end
           private_class_method :build_text
 
-          # 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 do |prop|
-              prop.association_id &&
-                (exclude_association_ids.nil? ||
-                 exclude_association_ids.include?(prop.association_id))
-            end
+          # Association ends remain in the model for connector role labels,
+          # but never become class-compartment attribute rows. The public
+          # exclude_association_ids keyword remains accepted for callers.
+          def self.displayable_properties(classifier, _exclude_association_ids)
+            classifier.properties&.reject(&:association_id)
           end
           private_class_method :displayable_properties
 

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

@@ -31,7 +31,7 @@ module Ea
             # @return [Array<String>] «name» labels (EA renders one
             # line per applied stereotype)
             def self.label_for(classifier, umldi_keyword, stereotype_fqname = nil)
-              return ["«#{umldi_keyword}»"] if umldi_keyword && !umldi_keyword.empty?
+              return ["«#{canonical(umldi_keyword, stereotype_fqname)}»"] if umldi_keyword && !umldi_keyword.empty?
 
               explicit = explicit_stereotype(classifier, stereotype_fqname)
               return explicit if explicit

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

@@ -61,6 +61,8 @@ module Ea
           return [] unless context
 
           record_drawn_bounds(element, context)
+          return [] if element.style&.fetch("connector_proxy", false)
+
           Compartment.render_all(context).compact
         end
 

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

@@ -341,9 +341,21 @@ module Ea
             inset, baseline = property_role_offsets(direction)
             left = property_role_x(direction, x, inset + width)
             left = [left, MIN_ROLE_X].max if direction == :up
+            left += source_property_centering(connector, direction, box, role)
             [left, y + baseline]
           end
 
+          # 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 seat_font? && font_weight == 400 && font_style == "normal"
+            return 0 unless box.values_at("cy", "alignment") == [35, 1]
+
+            stereo = "«#{connector_source_dest_stereotype(connector, :source)}»"
+            -[stereotype_offset(role, stereo, box), 0].min
+          end
+
           def source_property_seat?(connector, direction, box)
             phantom_property_box?(connector, direction, box) ||
               (%i[up left right down].include?(direction) &&
@@ -885,8 +897,7 @@ module Ea
             # relationship guid), falling back to the property index
             # lookup by association source/target id.
             if connector&.relationship_ref
-              placed = placed_classifier_id(association, end_kind)
-              prop = assoc_end_property(placed, connector.relationship_ref)
+              prop = placed_end_property(association, end_kind, connector.relationship_ref)
               return prop if prop
             end
 
@@ -898,13 +909,27 @@ module Ea
             fallback_property_lookup(id)
           end
 
+          def placed_end_property(association, end_kind, relationship_ref)
+            placed = placed_classifier_id(association, end_kind)
+            property = assoc_end_property(placed, relationship_ref)
+            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.
+          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
+          end
+
           def placed_classifier_id(association, end_kind)
             end_kind == :source ? association.source_id : association.target_id
           end
 
-          # Find the synthesized association-end property on the
-          # placed classifier whose association_id matches the
-          # connector's relationship reference.
+          # Named association-end properties carry typed labels. Unnamed
+          # XMI member-end references defer to the saved association role
+          # and cardinality; direct property-id endpoints are resolved above.
           def assoc_end_property(classifier_id, relationship_ref)
             return nil unless classifier_id
 
@@ -912,7 +937,7 @@ module Ea
             return nil unless classifier.is_a?(Ea::Model::Classifier)
 
             (classifier.properties || []).find do |p|
-              p.association_id == relationship_ref
+              p.association_id == relationship_ref && !p.name.to_s.empty?
             end
           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.134"
+  VERSION = "0.6.136"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.134
+  version: 0.6.136
 platform: ruby
 authors:
 - Ribose Inc.
@@ -852,6 +852,9 @@ files:
 - lib/ea/sources/xmi/annotation_builder.rb
 - lib/ea/sources/xmi/classifier_builder.rb
 - lib/ea/sources/xmi/diagram_builder.rb
+- lib/ea/sources/xmi/diagram_builder/connector_metadata.rb
+- lib/ea/sources/xmi/diagram_builder/font_settings.rb
+- lib/ea/sources/xmi/diagram_builder/stereotype_profiles.rb
 - lib/ea/sources/xmi/diagram_builder/umldi_edges.rb
 - lib/ea/sources/xmi/extension_elements.rb
 - lib/ea/sources/xmi/extension_geometry_parser.rb