ea 0.6.135 → 0.6.137

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c90b3802a319e6dec5d22f9d196bfc328c942c679925634774dc55780874deef
-  data.tar.gz: 737a502a84e3a08c01070024b0793204ae4c460c928fbd531297fbd3d02fdf82
+  metadata.gz: 86d6c89e9ac852772ebf6ee8eca6f4a08550af81c7f48908655c94b4bc8ab18c
+  data.tar.gz: 6ebe1a0e0647909564a7a403730e4041a8eb639ded4479deebbc19db6f3e8e5a
 SHA512:
-  metadata.gz: a3df522a4725e068ec20bd515db2b35c058f270819cf5f503c187c59dc0d1db7b4b21e3e9d886db33c5960f2510bbe55b47ddddb0731f8c22a55b97e8d25b789
-  data.tar.gz: a2319133a4bcc7e0473ec82128b8b23205134cf5e09804f60b15c9e0a9a76ebd3795d6dea3566a4827fcc52b91c65dc14c521d93fbf5133ea63aa189bf229098
+  metadata.gz: 91e45ba11088734c4ad3998c124945a4a80fc1001e7f3384fd69c02087e7578fcb2d2d1b8c3a6e1b183e26b03c7debd00fc1bdebe216337cb55855573f85f157
+  data.tar.gz: 6edd840e00dbf74517daad8bd65e2c28d0cec57ad1c02a15016417327d7c3e7dbd1bacfa22c25f6d62d60af632b4d6812110d31523c642a670b386bb86f1a448

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        # EA stores the association-class reference, connector subtype and proxy
+        # classifiers in extension attributes omitted by the XMI model gem.
+        class AssociationClassMetadata
+          def initialize(xmi_path)
+            @xmi_path = xmi_path
+          end
+
+          def for(connector, placed_subjects:, waypoints:)
+            return unless valid_tether?(connector, waypoints)
+
+            attached_id = connector_data.dig(connector.idref, :association_class)
+            return unless attached_id && class_ids.include?(attached_id)
+            return unless placed_subjects.any? { |subject| guid_key(subject) == guid_key(attached_id) }
+
+            attached_id
+          end
+
+          private
+
+          def valid_tether?(connector, waypoints)
+            @xmi_path && connector && association_class?(connector) &&
+              proxy_pair?(connector) && coincident_route?(waypoints)
+          end
+
+          def association_class?(connector)
+            connector.properties&.ea_type == "Association" &&
+              connector_data.dig(connector.idref, :subtype) == "Class" &&
+              connector_data.dig(connector.idref, :private_data).to_s.match?(/\A[1-9]\d*\z/)
+          end
+
+          def proxy_pair?(connector)
+            endpoints = [connector.source, connector.target]
+            return false unless proxy_endpoints?(endpoints)
+
+            classifiers = endpoints.map { |endpoint| proxy_classifiers[endpoint.idref] }
+            matching_classifiers?(classifiers)
+          end
+
+          def proxy_endpoints?(endpoints)
+            endpoints.all? { |endpoint| endpoint&.model&.type == "ProxyConnector" }
+          end
+
+          def matching_classifiers?(classifiers)
+            classifiers.none? { |classifier| classifier.to_s.empty? } && classifiers.uniq.one?
+          end
+
+          def coincident_route?(waypoints)
+            first = waypoints&.first&.position
+            last = waypoints&.last&.position
+            first && last && first.x == last.x && first.y == last.y
+          end
+
+          def connector_data
+            @connector_data ||= read_metadata.fetch(:connectors)
+          end
+
+          def proxy_classifiers
+            @proxy_classifiers ||= read_metadata.fetch(:proxies)
+          end
+
+          def class_ids
+            @class_ids ||= read_metadata.fetch(:classes)
+          end
+
+          def read_metadata
+            @read_metadata ||= scan_metadata
+          end
+
+          def scan_metadata
+            data = { connectors: {}, proxies: {}, classes: [] }
+            File.open(@xmi_path) do |file|
+              Nokogiri::XML::Reader(file).each { |node| read_node(node, data) }
+            end
+            data
+          end
+
+          def read_node(node, data)
+            return unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+
+            read_element(node, data) if node.local_name == "element"
+            read_connector(node, data) if node.local_name == "connector"
+          end
+
+          def read_element(node, data)
+            element = Nokogiri::XML(node.outer_xml).root
+            id = attr(element, "idref")
+            return unless id
+
+            type = attr(element, "type")
+            data[:classes] << id if type == "uml:Class"
+            data[:proxies][id] = attr(element, "classifier") if type == "uml:ProxyConnector"
+          end
+
+          def read_connector(node, data)
+            connector = Nokogiri::XML(node.outer_xml).root
+            id = attr(connector, "idref")
+            return unless id
+
+            extended = connector.at_xpath("./*[local-name()='extendedProperties']")
+            properties = connector.at_xpath("./*[local-name()='properties']")
+            data[:connectors][id] = {
+              subtype: attr(properties, "subtype"),
+              association_class: attr(extended, "associationclass"),
+              private_data: attr(extended, "privatedata1")
+            }
+          end
+
+          def attr(node, name)
+            node&.attribute_nodes&.find { |attribute| attribute.name == name }&.value
+          end
+
+          def guid_key(subject)
+            subject&.sub(/\AEA(?:ID|PK)_/, "")&.upcase
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,7 @@ module Ea
       # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
         autoload :ConnectorMetadata, "ea/sources/xmi/diagram_builder/connector_metadata"
+        autoload :AssociationClassMetadata, "ea/sources/xmi/diagram_builder/association_class_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"
@@ -44,7 +45,7 @@ module Ea
 
         def build_one(ext_diagram)
           id = IdNormalizer.from_xmi_id(ext_diagram.id)
-          ext_elements = ExtensionElements.new(ext_diagram)
+          ext_elements = ExtensionElements.new(ext_diagram, connector_subjects: connector_index)
           placed_elements = ext_elements.placed_elements
           placed_connectors = ext_elements.placed_connectors
           props = ext_diagram.properties
@@ -130,6 +131,7 @@ module Ea
             line_width: style.line_width,
             font_family: font[:family],
             font_size: font[:size],
+            font_size_unit: "pt",
             font_logical_height: font[:logical_height],
             font_size_inherited: ExtensionStyleParser.split_pairs(style.raw.to_s)["fontsz"] == "0",
             font_bold: style.bold,
@@ -140,10 +142,32 @@ module Ea
             z_order: placed.seqno,
             duid: style.duid,
             umldi_keyword: umldi_keywords[placed.subject],
-            style: (@stereotype_profiles ||= StereotypeProfiles.new(root)).for(placed.subject)
+            style: element_style(placed.subject)
           )
         end
 
+        # XMI preserves UML member order in ownedAttribute. Carry that
+        # provenance to the renderer so it does not replace it with a name sort.
+        def element_style(subject)
+          style = (@stereotype_profiles ||= StereotypeProfiles.new(root)).for(subject)
+          return style unless source_ordered_classifiers.include?(subject)
+
+          style.merge(stored_attribute_order: true)
+        end
+
+        def source_ordered_classifiers
+          @source_ordered_classifiers ||= begin
+            ids = []
+            visit = lambda do |element|
+              ids << element.id if TypeClassifierMap.classifier_type?(element.type)
+              element.packaged_element.to_a.each { |child| visit.call(child) }
+              element.nested_classifier.to_a.each { |child| visit.call(child) }
+            end
+            root.model&.packaged_element.to_a.each { |element| visit.call(element) }
+            ids
+          end
+        end
+
         def build_bounds(left, top, right, bottom)
           return nil unless left && top && right && bottom
 
@@ -160,16 +184,33 @@ module Ea
           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, by_subject, owner_id, index)
+            connector = build_connector(placed, by_duid, by_subject, owner_id, index)
+            mark_association_class(connector, placed, placed_elements)
           end
         end
 
+        def mark_association_class(connector, placed, placed_elements)
+          reference = association_class_metadata.for(
+            connector_index[placed.subject],
+            placed_subjects: placed_elements.map(&:subject),
+            waypoints: connector.waypoints
+          )
+          if reference
+            connector.style[:association_class_ref] = reference
+            connector.source_anchor = connector.waypoints.first.position
+          end
+          connector
+        end
+
+        def association_class_metadata
+          @association_class_metadata ||= AssociationClassMetadata.new(xmi_path)
+        end
+
         def build_connector(placed, by_duid, by_subject, owner_id, rank)
           geom = placed.geometry
           style = placed.style
-          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)
+          edge_source, edge_target = connector_ends(owner_id, placed)
+          source, target = placed_ends(style, by_duid, by_subject, edge_source, edge_target)
           ext_meta = connector_meta(placed.subject)
           route = connector_route(placed, source, target, owner_id, ext_meta[:ea_type])
           Ea::Model::DiagramConnector.new(
@@ -197,6 +238,23 @@ module Ea
           )
         end
 
+        # The saved SOID/EOID can name the model connector's ends in reverse
+        # order; the model connector decides which placement is the source.
+        def placed_ends(style, by_duid, by_subject, edge_source, edge_target)
+          source = by_duid[style.soid] || sole_placement(by_subject, edge_source)
+          target = by_duid[style.eoid] || sole_placement(by_subject, edge_target)
+          return [source, target] unless source && target &&
+                                         reversed_ends?(source, target, edge_source, edge_target)
+
+          [target, source]
+        end
+
+        def reversed_ends?(source, target, edge_source, edge_target)
+          guid_key(edge_source) != guid_key(edge_target) &&
+            guid_key(source.subject) == guid_key(edge_target) &&
+            guid_key(target.subject) == guid_key(edge_source)
+        end
+
         def connector_meta(subject_id)
           connector = connector_index[subject_id]
           return { ea_type: nil, direction: nil } unless connector
@@ -242,7 +300,18 @@ module Ea
           points = native || compute_waypoints(placed.geometry, source, target,
                                                style: placed.style, connector_type: type)
           native ||= umldi_waypoints(owner_id, placed) if points.empty?
-          { waypoints: native || points, style: native ? { umldi_route: true } : {} }
+          { waypoints: native || points, style: connector_route_style(placed, native) }
+        end
+
+        def connector_route_style(placed, native)
+          route_style = native ? { umldi_route: true } : {}
+          # Label seats use EA's saved routing mode on every route source;
+          # umldi_route still marks UMLDI waypoints as authoritative.
+          route_style.merge!(Qea::DiagramStyleParser.parse(placed.style.raw).slice(:mode, :lwidth, :tree))
+          # Source-known links without DUIDs use classifier endpoint metadata,
+          # not a saved label box that might refer to the opposite end.
+          route_style[:explicit_end_roles] = true unless placed.style.soid && placed.style.eoid
+          route_style
         end
 
         # EA's unique exported edge supplies bendless routes and recovers
@@ -254,6 +323,15 @@ module Ea
           route&.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
         end
 
+        def connector_ends(diagram_id, placed)
+          umldi_ends(diagram_id, placed) || extension_ends(placed.subject)
+        end
+
+        def extension_ends(subject)
+          connector = connector_index[subject]
+          [connector&.source&.idref, connector&.target&.idref]
+        end
+
         def umldi_ends(diagram_id, placed)
           return unless xmi_path
 

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

@@ -12,8 +12,9 @@ module Ea
       class ExtensionElements
         attr_reader :diagram
 
-        def initialize(diagram)
+        def initialize(diagram, connector_subjects: {})
           @diagram = diagram
+          @connector_subjects = connector_subjects
         end
 
         def placed_elements
@@ -53,9 +54,9 @@ module Ea
 
           placement = ExtensionGeometryParser.parse(row.geometry)
           style = ExtensionStyleParser.parse(row.style)
-          # Connectors carry SOID/EOID in their style; geometry has
-          # only bend routing.
-          return nil unless style.soid && style.eoid
+          # Some EA placements omit both DUIDs. The extension connector
+          # index still identifies these rows without treating shapes as links.
+          return nil unless (style.soid && style.eoid) || @connector_subjects.key?(row.subject)
 
           PlacedConnector.new(
             subject: row.subject,

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

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

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

@@ -64,10 +64,37 @@ module Ea
 
         def bent_points(src, bends, tgt, link, connector, source, target)
           points = [src, *bends, tgt]
-          redock_parent_above(points, link, source, target) if connector.connector_type == "Generalization"
+          if connector.connector_type == "Generalization"
+            preserve_side_entry = authored_lateral_side_entry?(points, bends, link, source, target)
+            redock_parent_above(points, link, source, target)
+            points[-1] = [points[-1][0], points[1][1]] if preserve_side_entry
+          end
           points
         end
 
+        # A single LH tree bend can be the authored side-entry level itself.
+        # Parent-above redocking normally moves a Generalization to the target
+        # bottom, which destroys that horizontal leg and disagrees with QEA.
+        def authored_lateral_side_entry?(points, bends, link, source, target)
+          return false unless bends.one? && points.size == 3 && lateral_side_entry_style?(link) &&
+                              target.y + target.height <= source.y
+
+          level_on_target_side?(points[1], target)
+        end
+
+        def lateral_side_entry_style?(link)
+          style = Qea::DiagramStyleParser.parse(link.style)
+          style[:mode] == "3" && style[:tree] == "LH" && style[:lwidth] == "2"
+        end
+
+        def within_width?(x, bounds)
+          x.between?(bounds.x, bounds.x + bounds.width)
+        end
+
+        def level_on_target_side?(bend, target)
+          bend[1].between?(target.y, target.y + target.height) && !within_width?(bend[0], target)
+        end
+
         def finish(points, link, connector, source, target, bends, ports, offsets, edge)
           tree_route = stored_tree_route(points, link, connector, source, target, ports)
           if tree_route

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

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

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

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

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

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

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

@@ -66,7 +66,7 @@ module Ea
             if role_empty?(role) && mult_empty?(mult)
               other_from_prop, other_role, other_mult = role_and_multiplicity(connector,
                                                               opposite(end_kind))
-              if stored_labels
+              if stored_labels || connector.style.to_h[:explicit_end_roles]
                 return [] if role_empty?(other_role) && mult_empty?(other_mult)
 
                 return own_stereotype_only(text_box, anchor, connector,

data/lib/ea/theme/definition.rb

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

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.135"
+  VERSION = "0.6.137"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.135
+  version: 0.6.137
 platform: ruby
 authors:
 - Ribose Inc.
@@ -852,6 +852,7 @@ 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/association_class_metadata.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