ea 0.6.133 → 0.6.135

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 020f344524c3f0702e581b349d7cb3f93a7069a3179684ca59440fd4d4762491
-  data.tar.gz: 46f2d46ab28ba95e5c975fedfa9bcd176c19b2acc4f3803635786f070dd315c2
+  metadata.gz: c90b3802a319e6dec5d22f9d196bfc328c942c679925634774dc55780874deef
+  data.tar.gz: 737a502a84e3a08c01070024b0793204ae4c460c928fbd531297fbd3d02fdf82
 SHA512:
-  metadata.gz: 16f49f774901e21cee845099df07ff8adc9989c3679c03fb49b97692356a81353d40c73c1cdde5dddfcd74b49657744695b61dbf557c96aabebe730fa4f0a7c4
-  data.tar.gz: 77fbf77c4cc929cb5565f2a9f712275b13e7244591b2dea3245d4ad096889531af5782aa4a8ad4888d9a2944e789fa9edd2657eb11cc5c93c5c6e9f17a7df3a0
+  metadata.gz: a3df522a4725e068ec20bd515db2b35c058f270819cf5f503c187c59dc0d1db7b4b21e3e9d886db33c5960f2510bbe55b47ddddb0731f8c22a55b97e8d25b789
+  data.tar.gz: a2319133a4bcc7e0473ec82128b8b23205134cf5e09804f60b15c9e0a9a76ebd3795d6dea3566a4827fcc52b91c65dc14c521d93fbf5133ea63aa189bf229098

data/lib/ea/model/document.rb

@@ -58,11 +58,8 @@ module Ea
       # `model_element_ref` lookups from diagram elements resolve.
       def index_by_id
         @index_by_id ||= begin
-          idx = {}
-          packages.each do |p|
-            idx[p.id] = p
-            alias_eaid_for_package(idx, p)
-          end
+          idx = PackageAliasIndex.new
+          packages.each { |p| idx[p.id] = p }
           classifiers.each { |c| idx[c.id] = c }
           relationships.each { |r| idx[r.id] = r }
           stereotypes.each { |s| idx[s.id] = s }
@@ -98,12 +95,6 @@ module Ea
         property_index[id]
       end
 
-      def alias_eaid_for_package(idx, package)
-        return unless package.id&.start_with?("EAPK_")
-
-        idx["EAID_#{package.id[5..]}"] = package
-      end
-
       def root_packages
         packages.select { |p| p.parent_id.nil? }
       end

data/lib/ea/model/package_alias_index.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Id-keyed lookup in which a package stored under `EAPK_<guid>`
+    # also answers to `EAID_<guid>`, without a second entry: `values`
+    # lists each package once.
+    class PackageAliasIndex < Hash
+      def [](id)
+        super || package_alias(id)
+      end
+
+      private
+
+      def package_alias(id)
+        return unless id.is_a?(String) && id.start_with?("EAID_")
+
+        fetch("EAPK_#{id[5..]}", nil)
+      end
+    end
+  end
+end

data/lib/ea/model.rb

@@ -19,6 +19,7 @@ module Ea
     autoload :Base, "ea/model/base"
     autoload :Metadata, "ea/model/metadata"
     autoload :Point, "ea/model/point"
+    autoload :PackageAliasIndex, "ea/model/package_alias_index"
     autoload :Bounds, "ea/model/bounds"
     autoload :Waypoint, "ea/model/waypoint"
     autoload :Annotation, "ea/model/annotation"

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),
@@ -82,18 +90,16 @@ module Ea
           { literals: literals }
         end
 
-        def qualified_name(element, containing_package)
-          # The XMI's `name` attribute may already be in
-          # "ns:Class" form (e.g. "xs:string" lives in the `xs`
-          # package). Forcing the package name in front would
-          # produce "xs::xs:string". Strip the existing namespace
-          # prefix from the simple name before composing the
-          # qualified name.
-          raw = element.name.to_s
-          simple = raw.split(":").last
-          simple = raw if simple.nil? || simple.empty?
+        # A name that already carries a namespace prefix
+        # (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}::#{simple}" : simple
+          pkg_name ? "#{pkg_name}::#{name}" : name
         end
 
         def boolean(value)

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/umldi_edges.rb

@@ -6,9 +6,10 @@ module Ea
   module Sources
     module Xmi
       class DiagramBuilder
-        # Ordered waypoints of the UMLDI edge EA exported for a connector
-        # on a diagram. A connector drawn by more than one edge in the same
-        # diagram, or by an edge with fewer than two waypoints, has no route.
+        # The UMLDI edge EA exported for a connector on a diagram: its
+        # ordered waypoints and its source/target model elements. A connector
+        # drawn by more than one edge in the same diagram has neither; an edge
+        # with fewer than two waypoints has no route.
         class UmldiEdges
           def initialize(xmi_path)
             @xmi_path = xmi_path
@@ -18,8 +19,34 @@ module Ea
             routes.dig(diagram_id, connector_id)
           end
 
+          def ends_for(diagram_id, connector_id)
+            ends.dig(diagram_id, connector_id)
+          end
+
           private
 
+          def ends
+            @ends ||= doc.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
+              [diagram["id"] || diagram["xmi:id"], diagram_ends(diagram)]
+            end
+          end
+
+          def diagram_ends(diagram)
+            unique_edges(diagram).each_with_object({}) do |(connector_id, edge), acc|
+              acc[connector_id] = [edge["source"], edge["target"]] if edge["source"] && edge["target"]
+            end
+          end
+
+          # Edges keyed by connector, keeping only connectors drawn by exactly
+          # one edge of the diagram, whatever that edge carries.
+          def unique_edges(diagram)
+            diagram.xpath("./ownedElement[@modelElement]")
+                   .select { |node| node.attributes["type"]&.value.to_s.end_with?("UMLEdge") }
+                   .group_by { |edge| edge["modelElement"] }
+                   .select { |_, same| same.one? }
+                   .transform_values(&:first)
+          end
+
           def routes
             @routes ||= doc.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
               [diagram["id"] || diagram["xmi:id"], diagram_routes(diagram)]
@@ -27,9 +54,8 @@ module Ea
           end
 
           def diagram_routes(diagram)
-            edges = diagram.xpath("./ownedElement[@modelElement][waypoint]").group_by { |edge| edge["modelElement"] }
-            edges.each_with_object({}) do |(connector_id, same), acc|
-              points = same.one? ? waypoints(same.first) : []
+            unique_edges(diagram).each_with_object({}) do |(connector_id, edge), acc|
+              points = waypoints(edge)
               acc[connector_id] = points if points.size >= 2
             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
@@ -52,10 +55,14 @@ module Ea
             name: props&.name || ext_diagram.id,
             package_id: ext_diagram.model&.package,
             diagram_type: props&.type&.split(":")&.last&.downcase,
-            bounds: canvas_bounds(placed_elements),
+            bounds: page_bounds(ext_diagram),
             style: style_for(ext_diagram),
             style_ex: style_ex_for(ext_diagram),
             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),
@@ -89,18 +96,18 @@ module Ea
 
         private
 
-        def canvas_bounds(placed_elements)
-          return nil if placed_elements.empty?
+        def style_flag?(ext_diagram, key)
+          value = style_for(ext_diagram).to_s[/(?:\A|;)#{key}=(\d+)/, 1]
+          value.to_i.nonzero? ? true : false
+        end
 
-          left = placed_elements.map { |e| e.geometry.img_left || e.geometry.left }.compact.min
-          top = placed_elements.map { |e| e.geometry.img_top || e.geometry.top }.compact.min
-          right = placed_elements.map { |e| e.geometry.img_right || e.geometry.right }.compact.max
-          bottom = placed_elements.map { |e| e.geometry.img_bottom || e.geometry.bottom }.compact.max
-          return nil unless left && top && right && bottom
+        def page_bounds(ext_diagram)
+          style = style_for(ext_diagram).to_s
+          width = style[/(?:\A|;)DocSize\.cx=(\d+)/, 1]
+          height = style[/(?:\A|;)DocSize\.cy=(\d+)/, 1]
+          return nil unless width && height
 
-          Ea::Model::Bounds.new(x: 0, y: 0,
-                                 width: right - left,
-                                 height: bottom - top)
+          Ea::Model::Bounds.new(x: 0, y: 0, width: width.to_i, height: height.to_i)
         end
 
         def build_elements(placed, owner_id, umldi_keywords = {})
@@ -110,17 +117,21 @@ module Ea
         def build_element(placed, owner_id, umldi_keywords = {})
           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,
             model_element_ref: placed.subject,
-            bounds: build_bounds(geom.left, geom.top, geom.right, geom.bottom),
-            image_bounds: build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom),
+            bounds: bounds,
+            image_bounds: (build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom) unless bounds),
             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,
@@ -129,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
 
@@ -146,17 +157,19 @@ module Ea
           by_duid = placed_elements.each_with_object({}) do |pe, acc|
             acc[pe.style.duid] = pe if pe.style.duid
           end
+          by_subject = placed_elements.group_by { |pe| guid_key(pe.subject) }
 
           placed_connectors.each_with_index.map do |placed, index|
-            build_connector(placed, by_duid, owner_id, index)
+            build_connector(placed, by_duid, by_subject, owner_id, index)
           end
         end
 
-        def build_connector(placed, by_duid, owner_id, rank)
+        def build_connector(placed, by_duid, by_subject, owner_id, rank)
           geom = placed.geometry
           style = placed.style
-          source = by_duid[style.soid]
-          target = by_duid[style.eoid]
+          edge_source, edge_target = umldi_ends(owner_id, placed)
+          source = by_duid[style.soid] || sole_placement(by_subject, edge_source)
+          target = by_duid[style.eoid] || sole_placement(by_subject, edge_target)
           ext_meta = connector_meta(placed.subject)
           route = connector_route(placed, source, target, owner_id, ext_meta[:ea_type])
           Ea::Model::DiagramConnector.new(
@@ -172,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,
@@ -189,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
@@ -234,6 +254,23 @@ module Ea
           route&.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
         end
 
+        def umldi_ends(diagram_id, placed)
+          return unless xmi_path
+
+          umldi_edges.ends_for(diagram_id, placed.subject)
+        end
+
+        def sole_placement(by_subject, subject)
+          placements = by_subject[guid_key(subject)]
+          placements.first if placements&.one?
+        end
+
+        # EA spells one GUID with an EAID_ or EAPK_ prefix and mixed case
+        # depending on the element kind.
+        def guid_key(subject)
+          subject&.sub(/\AEA(?:ID|PK)_/, "")&.upcase
+        end
+
         def umldi_edges
           @umldi_edges ||= UmldiEdges.new(xmi_path)
         end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Builds an `Ea::Model::Legend` from the `value` of an element's
+      # `<xrefs>` element. The CustomProperties description inside it
+      # uses the same `@PROP=...@ENDPROP;` encoding as the QEA t_xref
+      # row, so parsing is delegated to the QEA legend builder.
+      #
+      # Returns nil when the value carries no legend properties.
+      class LegendBuilder
+        CLIENT = "xmi-element"
+
+        XrefRow = Struct.new(:name, :description)
+
+        # Answers the one CustomProperties xref lookup the QEA builder makes.
+        class SingleElementXrefs
+          def initialize(description)
+            @rows = [XrefRow.new(Qea::LegendBuilder::LEGEND_XREF_NAME, description)]
+          end
+
+          def xrefs_for_client(_guid)
+            @rows
+          end
+        end
+
+        def initialize(xrefs_value)
+          @xrefs_value = xrefs_value
+        end
+
+        def build
+          return nil if @xrefs_value.to_s.empty?
+
+          Qea::LegendBuilder.new(SingleElementXrefs.new(@xrefs_value)).build_for(CLIENT)
+        end
+      end
+    end
+  end
+end

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

@@ -10,9 +10,12 @@ module Ea
       # inside `<xmi:Extension>/<elements>`. Each carries a
       # `<properties documentation="..."/>` child with the body text.
       #
-      # The xmi gem parses Note elements as part of the extension
-      # block; we walk them and project to Ea::Model::Note.
+      # `uml:Text` elements are projected the same way; those whose
+      # CustomProperties xref carries legend configuration also
+      # get an `Ea::Model::Legend` payload.
       class NoteBuilder
+        NOTE_TYPES = { "uml:Note" => "Note", "uml:Text" => "Text" }.freeze
+
         attr_reader :root
 
         def initialize(root)
@@ -29,17 +32,23 @@ module Ea
         private
 
         def build_one(ext_element)
-          type = ext_element.type
-          return nil unless type == "uml:Note"
+          note_type = NOTE_TYPES[ext_element.type]
+          return nil unless note_type
 
-          props = ext_element.properties
           Ea::Model::Note.new(
             id: ext_element.idref,
             name: ext_element.name,
-            body: props&.documentation,
-            note_type: "Note"
+            body: ext_element.properties&.documentation,
+            note_type: note_type,
+            legend: legend_for(ext_element, note_type)
           )
         end
+
+        def legend_for(ext_element, note_type)
+          return nil unless note_type == "Text"
+
+          LegendBuilder.new(ext_element.xrefs&.value).build
+        end
       end
     end
   end

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

@@ -9,6 +9,8 @@ module Ea
       class RelationshipBuilder
         # Connector types that imply an aggregation on the source end
         # when the end itself records none.
+        CONNECTOR_STEREOTYPE = /(?<=@STEREO;Name=)[^;]+/
+
         AGGREGATION_FOR_CONNECTOR_TYPE = {
           "Aggregation" => "shared",
           "Composition" => "composite"
@@ -22,13 +24,13 @@ 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
+          relationships + package_import_relationships(relationships)
         end
 
         def build_one(element)
@@ -40,9 +42,44 @@ module Ea
 
         private
 
+        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"
+
+            package_import_relationship(id, connector)
+          end
+        end
+
+        def connector_stereotype(connector)
+          connector&.xrefs&.value.to_s[CONNECTOR_STEREOTYPE]
+        end
+
+        def package_import_relationship(id, connector)
+          Ea::Model::Association.new(
+            id: id,
+            stereotype: connector_stereotype(connector),
+            source_id: connector.source&.idref,
+            target_id: connector.target&.idref,
+            source_navigable: navigable?(id, :source),
+            target_navigable: navigable?(id, :target)
+          )
+        end
+
         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)
@@ -51,6 +88,7 @@ module Ea
             id: id,
             name: element.name,
             qualified_name: element.name,
+            stereotype: connector_stereotype(connector_index[id]),
             annotations: AnnotationBuilder.from_element(element, id)
           }
         end
@@ -88,8 +126,8 @@ module Ea
             target_multiplicity_raw: raw_card(target.type&.multiplicity),
             source_aggregation: source_aggregation(connector),
             target_aggregation: target.type&.aggregation || "none",
-            source_navigable: navigable?(element, :source),
-            target_navigable: navigable?(element, :target)
+            source_navigable: navigable?(element.id, :source),
+            target_navigable: navigable?(element.id, :target)
           }
         end
 
@@ -118,8 +156,8 @@ module Ea
             target_multiplicity_upper: parse_upper(target_end),
             source_aggregation: source_end&.aggregation || "none",
             target_aggregation: target_end&.aggregation || "none",
-            source_navigable: navigable?(element, :source),
-            target_navigable: navigable?(element, :target)
+            source_navigable: navigable?(element.id, :source),
+            target_navigable: navigable?(element.id, :target)
           }
         end
 
@@ -197,8 +235,8 @@ module Ea
           end
         end
 
-        def navigable?(element, endpoint)
-          connector = connector_index[element.id]
+        def navigable?(id, endpoint)
+          connector = connector_index[id]
           end_element = connector&.public_send(endpoint)
           flag = end_element&.modifiers&.is_navigable
           flag.nil? || flag

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/sources/xmi.rb

@@ -25,6 +25,7 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :TagBuilder, "ea/sources/xmi/tag_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"

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.133"
+  VERSION = "0.6.135"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.133
+  version: 0.6.135
 platform: ruby
 authors:
 - Ribose Inc.
@@ -680,6 +680,7 @@ files:
 - lib/ea/model/note.rb
 - lib/ea/model/operation.rb
 - lib/ea/model/package.rb
+- lib/ea/model/package_alias_index.rb
 - lib/ea/model/parameter.rb
 - lib/ea/model/point.rb
 - lib/ea/model/polymorphic_maps.rb
@@ -851,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
@@ -858,6 +862,7 @@ files:
 - lib/ea/sources/xmi/extension_types.rb
 - lib/ea/sources/xmi/id_normalizer.rb
 - lib/ea/sources/xmi/instance_builder.rb
+- lib/ea/sources/xmi/legend_builder.rb
 - lib/ea/sources/xmi/metadata_builder.rb
 - lib/ea/sources/xmi/note_builder.rb
 - lib/ea/sources/xmi/operation_builder.rb