ea 0.6.137 → 0.6.139

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86d6c89e9ac852772ebf6ee8eca6f4a08550af81c7f48908655c94b4bc8ab18c
-  data.tar.gz: 6ebe1a0e0647909564a7a403730e4041a8eb639ded4479deebbc19db6f3e8e5a
+  metadata.gz: 34c3f680cb51a88a683e57db2c059fcee8979e5b6b31cfaae4c3cbc3ac91ac86
+  data.tar.gz: a4cbd25958c54c24d6d1801bf4e4cc83f76f42d652f371cf9d491865160d7725
 SHA512:
-  metadata.gz: 91e45ba11088734c4ad3998c124945a4a80fc1001e7f3384fd69c02087e7578fcb2d2d1b8c3a6e1b183e26b03c7debd00fc1bdebe216337cb55855573f85f157
-  data.tar.gz: 6edd840e00dbf74517daad8bd65e2c28d0cec57ad1c02a15016417327d7c3e7dbd1bacfa22c25f6d62d60af632b4d6812110d31523c642a670b386bb86f1a448
+  metadata.gz: c87682bc64b73abb6502c0dfd71ca7b9209ab8bcd71b79762032d0c4008f80999e3785257b72f39d73a816247d1dbcc5580a70e64f526a8ee98ee1aab32b645a
+  data.tar.gz: ed3c4dd24e1ed8b1bd9c371545d56392cda07b2e0f3223f27d84761b728963c5df7df67fab8da905bdd586150fb94750a5cbe3f2bd1bec9fd11adfd3ec18b9c6

data/lib/ea/fonts/cambria_7_regular_widths.json

@@ -46,6 +46,7 @@
   "Z": 5,
   "[": 4,
   "]": 4,
+  "_": 4,
   "a": 5,
   "b": 5,
   "c": 4,

data/lib/ea/model/diagram_connector.rb

@@ -38,6 +38,9 @@ module Ea
       attribute :hidden, :boolean
       attribute :is_substitutable, :boolean, default: false
       attribute :label_boxes, :hash, default: -> { {} }
+      # Absolute labels saved by UML-DI when the EA extension omits the
+      # corresponding relative label boxes.
+      attribute :umldi_label_bounds, :hash, default: -> { {} }
       attribute :ghost_labels, GhostLabel, collection: true, initialize_empty: true
       # True when the t_diagramlinks.Geometry string carries explicit
       # SX/SY/EX/EY offset fields. EA renders the «import» package_anchor
@@ -86,6 +89,7 @@ module Ea
         map "lineWidth", to: :line_width
         map "hidden", to: :hidden, render_default: true
         map "labelBoxes", to: :label_boxes
+        map "umldiLabelBounds", to: :umldi_label_bounds
         map "ghostLabels", to: :ghost_labels, render_empty: true
         map "hasGeometryOffsets", to: :has_geometry_offsets, render_default: true
       end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      class DiagramBuilder
+        class UmldiEdges
+          # Association membership proves which saved role bounds an edge owns.
+          class PropertyRoles
+            def initialize(doc)
+              @doc = doc
+            end
+
+            def keys_for(diagram_id, connector_id)
+              property_roles.dig(diagram_id, connector_id) || []
+            end
+
+            private
+
+            def property_roles
+              @property_roles ||= begin
+                document = @doc
+                declared = declared_properties(document)
+                document.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
+                  [diagram["id"] || diagram["xmi:id"], diagram_property_roles(diagram, declared)]
+                end
+              end
+            end
+
+            def declared_properties(document)
+              members = document.xpath("//*[local-name()='memberEnd']").to_set do |node|
+                [node["xmi:idref"], node.parent["xmi:id"]]
+              end
+              document.xpath("//*[@association][@xmi:id]", "xmi" => "http://www.omg.org/spec/XMI/20131001")
+                      .filter_map do |node|
+                pair = [node["xmi:id"], node["association"]]
+                pair if node.attributes["type"]&.value == "uml:Property" && members.include?(pair)
+              end.to_set
+            end
+
+            def diagram_property_roles(diagram, declared)
+              unique_edges(diagram).transform_values do |edge|
+                edge.xpath("./ownedElement[@modelElement]").filter_map do |label|
+                  key = role_key(label)
+                  key if key &&
+                         declared.include?([label["modelElement"], edge["modelElement"]])
+                end
+              end
+            end
+
+            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 { |_, edges| edges.one? }.transform_values(&:first)
+            end
+
+            def role_key(label)
+              return unless label.attributes["type"]&.value.to_s.end_with?("UMLAssociationEndLabel")
+
+              case label["xmi:id"] || label["id"]
+              when /\AEAID_SEL/ then :source_role
+              when /\AEAID_TEL/ then :target_role
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,6 +11,8 @@ module Ea
         # drawn by more than one edge in the same diagram has neither; an edge
         # with fewer than two waypoints has no route.
         class UmldiEdges
+          autoload :PropertyRoles, "ea/sources/xmi/diagram_builder/umldi_edges/property_roles"
+
           def initialize(xmi_path)
             @xmi_path = xmi_path
           end
@@ -23,6 +25,20 @@ module Ea
             ends.dig(diagram_id, connector_id)
           end
 
+          # Absolute saved UMLDI bounds for connector label boxes. These are
+          # kept separate from extension label offsets: callers may use them
+          # when extension geometry is absent or the association owns the role.
+          def label_bounds_for(diagram_id, connector_id)
+            label_bounds.dig(diagram_id, connector_id)
+          end
+
+          # Role label keys whose UMLDI label is bound to the property that
+          # the connector's association declares, so the bounds describe that
+          # end's own role label rather than an unrelated label.
+          def property_role_keys_for(diagram_id, connector_id)
+            (@property_roles ||= PropertyRoles.new(doc)).keys_for(diagram_id, connector_id)
+          end
+
           private
 
           def ends
@@ -31,6 +47,46 @@ module Ea
             end
           end
 
+          def label_bounds
+            @label_bounds ||= doc.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
+              [diagram["id"] || diagram["xmi:id"], diagram_label_bounds(diagram)]
+            end
+          end
+
+          def diagram_label_bounds(diagram)
+            boxes_by_connector = unique_edges(diagram).to_h do |connector_id, edge|
+              [connector_id, edge_label_bounds(edge)]
+            end
+            boxes_by_connector.reject { |_, boxes| boxes.empty? }
+          end
+
+          def edge_label_bounds(edge)
+            edge.xpath("./ownedElement[@modelElement]").each_with_object({}) do |label, found|
+              bounds = label.at_xpath("./*[local-name()=\"bounds\"]")
+              key = label_key(label)
+              next unless key && bounds
+
+              found[key] = bounds_values(bounds)
+            rescue ArgumentError, TypeError
+              next
+            end
+          end
+
+          def bounds_values(bounds)
+            %w[x y width height].to_h { |attribute| [attribute.to_sym, Integer(bounds[attribute])] }
+          end
+
+          def label_key(label)
+            type = label.attributes["type"]&.value.to_s
+            role = (label["id"] || label["xmi:id"]).to_s
+            end_name = { "EAID_SEL" => "source", "EAID_SML" => "source",
+                         "EAID_TEL" => "target", "EAID_TML" => "target" }
+            side = end_name.find { |prefix, _| role.start_with?(prefix) }&.last
+            suffix = { "UMLAssociationEndLabel" => "role", "UMLMultiplicityLabel" => "multiplicity" }
+            label_kind = suffix[type.split(":").last]
+            "#{side}_#{label_kind}".to_sym if side && label_kind
+          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"]

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

@@ -50,6 +50,7 @@ module Ea
           placed_connectors = ext_elements.placed_connectors
           props = ext_diagram.properties
           umldi_keywords = keywords_for(id)
+          context = context_diagram?(ext_diagram)
 
           Ea::Model::Diagram.new(
             id: id,
@@ -65,8 +66,7 @@ module Ea
             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),
+            connectors: build_connectors(placed_connectors, placed_elements, id, context),
             annotations: []
           )
         end
@@ -102,6 +102,13 @@ module Ea
           value.to_i.nonzero? ? true : false
         end
 
+        def context_diagram?(ext_diagram)
+          name = ext_diagram.properties&.name.to_s
+          return true if name.match?(/\AContext Diagram: Package (Clients|Suppliers) of /i)
+
+          style_ex_for(ext_diagram).to_s.match(/(?:\A|;)SuppressFOC=(\d)/)&.public_send(:[], 1) != "1"
+        end
+
         def page_bounds(ext_diagram)
           style = style_for(ext_diagram).to_s
           width = style[/(?:\A|;)DocSize\.cx=(\d+)/, 1]
@@ -176,7 +183,7 @@ module Ea
                                  height: bottom - top)
         end
 
-        def build_connectors(placed_connectors, placed_elements, owner_id)
+        def build_connectors(placed_connectors, placed_elements, owner_id, context)
           # Index elements by DUID so we can resolve SOID/EOID.
           by_duid = placed_elements.each_with_object({}) do |pe, acc|
             acc[pe.style.duid] = pe if pe.style.duid
@@ -184,40 +191,46 @@ module Ea
           by_subject = placed_elements.group_by { |pe| guid_key(pe.subject) }
 
           placed_connectors.each_with_index.map do |placed, index|
-            connector = build_connector(placed, by_duid, by_subject, owner_id, index)
-            mark_association_class(connector, placed, placed_elements)
+            connector = build_connector(placed, by_duid, by_subject, owner_id, rank: index, context: context)
+            mark_association_class(connector, placed, placed_elements, context)
           end
         end
 
-        def mark_association_class(connector, placed, placed_elements)
+        def mark_association_class(connector, placed, placed_elements, context)
+          mark_plain_end_seats(connector, placed, context)
           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
+          return connector unless reference
+
+          connector.style[:association_class_ref] = reference
+          connector.source_anchor = connector.waypoints.first.position
           connector
         end
 
+        def mark_plain_end_seats(connector, placed, context)
+          mark_plain_source_seat(connector, placed, context)
+          mark_plain_target_seat(connector, placed, context)
+        end
+
         def association_class_metadata
           @association_class_metadata ||= AssociationClassMetadata.new(xmi_path)
         end
 
-        def build_connector(placed, by_duid, by_subject, owner_id, rank)
+        def build_connector(placed, by_duid, by_subject, owner_id, options)
           geom = placed.geometry
           style = placed.style
           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(
+          connector = Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic_id(owner_id, "conn", placed.subject),
             diagram_id: owner_id,
             relationship_ref: placed.subject,
-            paint_order: [rank],
+            paint_order: [options.fetch(:rank)],
             source_duid: style.soid,
             target_duid: style.eoid,
             source_element_ref: source && synthetic_element_id(owner_id, source),
@@ -234,8 +247,96 @@ module Ea
             line_color: style.color,
             line_width: style.line_width,
             hidden: style.hidden,
-            label_boxes: serialize_label_boxes(geom.label_boxes)
+            label_boxes: connector_label_boxes(placed, ext_meta[:ea_type],
+                                               options.fetch(:context) ? nil : owner_id)
           )
+          connector.umldi_label_bounds = if options.fetch(:context)
+                                           {}
+                                         else
+                                           umldi_label_bounds_for(owner_id, placed.subject,
+                                                                  connector.label_boxes)
+                                         end
+          mark_stored_ray(connector, placed, source, target) unless options.fetch(:context)
+          mark_association_route(connector, placed, source, target) unless options.fetch(:context)
+          connector
+        end
+
+        def umldi_label_bounds_for(owner_id, connector_id, label_boxes)
+          return {} unless xmi_path
+
+          bounds = umldi_edges.label_bounds_for(owner_id, connector_id)
+          return {} unless bounds
+
+          property_roles = umldi_edges.property_role_keys_for(owner_id, connector_id)
+          bounds.reject do |key, _|
+            extension_key = { source_role: :llt, source_multiplicity: :llb,
+                              target_role: :lrt, target_multiplicity: :lrb }.fetch(key)
+            label_boxes.key?(extension_key) && !property_roles.include?(key)
+          end
+        end
+
+        def mark_stored_ray(connector, placed, source, target)
+          return if connector.style[:umldi_route]
+
+          metadata = stored_ray_metadata(connector, placed, source, target)
+          metadata.each { |name, value| connector.public_send("#{name}=", value) }
+          return if metadata.empty? || connector.connector_type == "Generalization"
+
+          connector.style[:association_ray_outline] = true
+        end
+
+        def stored_ray_metadata(connector, placed, source, target, stage: :ray_metadata)
+          geom = placed.geometry
+          link = StoredRoute::Link.new(placed.style.raw, geom.path.to_s.tr("$", ";"))
+          bounds = { source: bounds_from_placed(source), target: bounds_from_placed(target) }
+          offsets = { source: [geom.sx, geom.sy], target: [geom.ex, geom.ey] }
+          StoredRoute.new.public_send(stage, connector, link: link, bounds: bounds, offsets: offsets, edge: geom.edge)
+        end
+
+        def mark_association_route(connector, placed, source, target)
+          metadata = stored_ray_metadata(connector, placed, source, target, stage: :association_route)
+          metadata.each { |name, value| connector.public_send("#{name}=", value) }
+        end
+
+        def mark_plain_source_seat(connector, placed, context)
+          return if context || !placed.geometry.path.to_s.empty? || connector.connector_type != "Aggregation"
+          return unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          return unless connector.source_stereotype.to_s.empty?
+
+          connector.style[:plain_source_seat] = true
+        end
+
+        def mark_plain_target_seat(connector, placed, context)
+          return if context || !placed.geometry.path.to_s.empty? || connector.connector_type != "Association"
+          return unless connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          return unless connector.target_stereotype.to_s.empty?
+
+          connector.style[:plain_target_seat] = true
+        end
+
+        PHANTOM_TYPES = %w[Association Aggregation].freeze
+
+        # EA exports a model relationship drawn without a diagram link row as
+        # an Association or Aggregation link with the default style and an
+        # all-zero, EDGE-less, bendless geometry; the QEA source builds it as
+        # a phantom connector.
+        def phantom_link?(placed, type)
+          PHANTOM_TYPES.include?(type) && placed.style.raw == ";Hidden=0;" && default_geometry?(placed.geometry)
+        end
+
+        def default_geometry?(geom)
+          geom.edge.nil? && [geom.sx, geom.sy, geom.ex, geom.ey].all?(&:zero?) &&
+            geom.path.to_s.empty? && geom.label_boxes.to_h.empty?
+        end
+
+        def connector_label_boxes(placed, type, owner_id)
+          return serialize_label_boxes(placed.geometry.label_boxes) unless phantom_link?(placed, type)
+
+          # An empty extension placement can still have saved UMLDI labels.
+          # Synthetic phantom offsets must not suppress those authored bounds.
+          return {} if owner_id && xmi_path && umldi_edges.label_bounds_for(owner_id, placed.subject)
+
+          Qea::DiagramBuilder::DEFAULT_LABEL_BOXES
         end
 
         # The saved SOID/EOID can name the model connector's ends in reverse
@@ -296,6 +397,10 @@ module Ea
         end
 
         def connector_route(placed, source, target, owner_id, type)
+          phantom_route(placed, source, target, type) || saved_route(placed, source, target, owner_id, type)
+        end
+
+        def saved_route(placed, source, target, owner_id, type)
           native = umldi_waypoints(owner_id, placed) if placed.geometry.bend_points.to_a.empty?
           points = native || compute_waypoints(placed.geometry, source, target,
                                                style: placed.style, connector_type: type)
@@ -303,6 +408,14 @@ module Ea
           { waypoints: native || points, style: connector_route_style(placed, native) }
         end
 
+        def phantom_route(placed, source, target, type)
+          return unless source && target && phantom_link?(placed, type)
+
+          points = StoredRoute.new.phantom_waypoints(bounds_from_placed(source), bounds_from_placed(target))
+          { waypoints: points.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) },
+            style: { lwidth: "1", phantom_outline: true } }
+        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;

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

@@ -26,8 +26,210 @@ module Ea
           finish(points, link, connector, source, target, bends, ports, offsets, edge)
         end
 
+        # Saved rays retain origins and computed boundary ports, matching QEA.
+        def ray_metadata(model, link:, bounds:, offsets:, edge:)
+          if model.connector_type == "Generalization"
+            return generalization_ray_metadata(model, link, bounds, offsets, edge)
+          end
+
+          return {} unless direct_association_ray?(model, bounds, offsets)
+
+          source, target = bounds.values_at(:source, :target)
+          geom = ray_geometry(offsets, edge)
+          return {} unless saved_association_ray?(model, link, source, target, geom)
+
+          ray_points(source, target, offsets, geom)
+        end
+
+        def phantom_waypoints(source, target)
+          [bounds_edge_point(source, target), bounds_edge_point(target, source)]
+        end
+
+        # Apply QEA's saved Association stages after the initial route, including
+        # UMLDI fallback. A single stored corner and an empty-path stored ray
+        # carry mathematical origins that the generic facing-edge route loses.
+        def association_route(model, link:, bounds:, offsets:, edge:)
+          overlap = umldi_association_metadata(model, link, bounds, offsets, edge)
+          return overlap unless overlap.empty?
+
+          partial = partial_port_metadata(model, link, bounds, offsets, edge)
+          return partial unless partial.empty?
+
+          return {} unless stored_association_candidate?(model, bounds)
+
+          candidate = association_model(model, bounds, offsets)
+          initial = candidate.waypoints
+          association_stored_ray(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} if candidate.waypoints.equal?(initial)
+
+          association_metadata(candidate)
+        end
+
         private
 
+        def umldi_association_metadata(model, link, bounds, offsets, edge)
+          overlap = umldi_overlap_metadata(model, link, bounds, offsets, edge)
+          return overlap unless overlap.empty?
+
+          umldi_stored_ray_metadata(model, link, bounds, offsets, edge)
+        end
+
+        # UMLDI owns the route and ports. Classify a thin saved ray only when
+        # its origins pass the shared unstroked-box checks; XMI has no QEA
+        # database from which to infer a wider element outline.
+        def umldi_stored_ray_metadata(model, link, bounds, offsets, edge)
+          return {} unless umldi_thin_ray_candidate?(model, bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          return {} unless association_ray_candidate?(candidate, link)
+          return {} unless association_ray_origins(*bounds.values_at(:source, :target),
+                                                   ray_geometry(offsets, edge), "0")
+
+          { style: model.style.to_h.merge(stored_association_ray: true, association_ray_outline: true) }
+        end
+
+        def umldi_thin_ray_candidate?(model, bounds, offsets)
+          model.style[:umldi_route] && model.style[:lwidth] == "0" &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # UMLDI owns the drawn route; retain QEA's overlap origins only for
+        # interpreting the stored relative end labels against that route.
+        def umldi_overlap_metadata(model, link, bounds, offsets, edge)
+          return {} unless umldi_overlap_candidate?(model, bounds, offsets)
+
+          candidate = association_model(model, bounds, offsets)
+          overlap_ray_origins(candidate, link, bounds, ray_geometry(offsets, edge), false)
+          return {} unless candidate.style[:overlap_ray]
+
+          { source_anchor: candidate.source_anchor, target_anchor: candidate.target_anchor,
+            has_geometry_offsets: true, style: candidate.style.to_h }
+        end
+
+        def umldi_overlap_candidate?(model, bounds, offsets)
+          model.style.to_h.values_at(:umldi_route, :mode, :lwidth) == [true, "2", "0"] &&
+            model.waypoints.size == 2 && bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # A zero-offset end has no explicit port, but QEA still carries both
+        # mathematical origins for the emitter's final boundary redocking.
+        def partial_port_metadata(model, link, bounds, offsets, edge)
+          return {} unless partial_port_candidate?(model, link, bounds, offsets)
+
+          source, target = bounds.values_at(:source, :target)
+          return {} unless saved_association_ray?(model, link, source, target, ray_geometry(offsets, edge))
+
+          association_ends(bounds, offsets).merge(has_geometry_offsets: true)
+        end
+
+        def partial_port_candidate?(model, link, bounds, offsets)
+          model.connector_type == "Aggregation" && !model.style[:umldi_route] && !link.path.to_s.empty? &&
+            direct_association_ray?(model, bounds, offsets) &&
+            offsets.values.count { |offset| offset.all?(&:zero?) } == 1
+        end
+
+        def stored_association_candidate?(model, bounds)
+          model.connector_type == "Association" && bounds.values.all? &&
+            association_ray_style?(model.style.to_h) && model.style[:lwidth] == "2"
+        end
+
+        def association_metadata(model)
+          fields = %i[waypoints source_anchor target_anchor source_port target_port has_geometry_offsets]
+          fields.to_h { |name| [name, model.public_send(name)] }.merge(
+            style: model.style.to_h.reject { |key, _| key == :umldi_route }
+          )
+        end
+
+        def association_model(model, bounds, offsets)
+          Ea::Model::DiagramConnector.new(
+            { connector_type: model.connector_type, style: model.style.to_h.dup, waypoints: model.waypoints,
+              has_geometry_offsets: !offsets[:source][0].nil? }.merge(association_ends(bounds, offsets))
+          )
+        end
+
+        def association_ends(bounds, offsets)
+          %i[source target].each_with_object({}) do |kind, result|
+            box = bounds.fetch(kind)
+            offset = offsets.fetch(kind)
+            port = port_for(box, offset)
+            result["#{kind}_port".to_sym] = point_for(port) if port
+            result["#{kind}_anchor".to_sym] = association_anchor(box, offset)
+          end
+        end
+
+        def association_anchor(box, offset)
+          Ea::Model::Point.new(x: box.x + box.width / 2 + offset[0].to_i,
+                               y: box.y + box.height / 2 + offset[1].to_i)
+        end
+
+        def stored_ray_boxes(_link, bounds)
+          bounds.values_at(:source, :target)
+        end
+
+        def direct_association_ray?(model, bounds, offsets)
+          %w[Association Aggregation].include?(model.connector_type) && model.waypoints.size == 2 &&
+            model.style.to_h.values_at(:mode, :lwidth, :tree) == ["1", "2", nil] &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?)
+        end
+
+        # A direct Generalization clips its saved mathematical origins rather
+        # than treating boundary ports as the origins of the final drawn ray.
+        def generalization_ray_metadata(model, link, bounds, offsets, edge)
+          geom = ray_geometry(offsets, edge)
+          return {} unless generalization_ray_candidate?(model, link, bounds, offsets, geom)
+
+          source, target = bounds.values_at(:source, :target)
+          return {} unless stored_ray_gap?(source, target, model.style[:mode], edge)
+
+          points = ray_points(source, target, offsets, geom)
+          return {} if points.empty?
+
+          points.merge(style: generalization_ray_style(model, points, source, target))
+        end
+
+        def generalization_ray_candidate?(model, link, bounds, offsets, geom)
+          model.waypoints.size == 2 && stored_ray_style?(model.style, link) &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?) &&
+            (!geom[:sy].zero? || !geom[:ey].zero?)
+        end
+
+        def generalization_ray_style(model, points, source, target)
+          candidate = Ea::Model::DiagramConnector.new(
+            connector_type: model.connector_type, style: model.style.to_h.dup,
+            source_anchor: points[:source_anchor], target_anchor: points[:target_anchor]
+          )
+          return model.style.to_h unless centered_origin_ray?(candidate, source, target)
+
+          flags = { centered_origin_ray: true }
+          flags[:stored_origin_ray] = true if stored_origin_ray?(candidate, source, target)
+          model.style.to_h.merge(flags)
+        end
+
+        def ray_geometry(offsets, edge)
+          { sx: offsets[:source][0], sy: offsets[:source][1],
+            ex: offsets[:target][0], ey: offsets[:target][1], edge: edge }
+        end
+
+        def saved_association_ray?(model, link, source, target, geom)
+          (!geom[:sy].zero? || !geom[:ey].zero?) &&
+            stored_ray_gap?(source, target, "1", geom[:edge]) &&
+            stored_association_path?(model, link, source, target, geom)
+        end
+
+        def ray_points(source, target, offsets, geom)
+          ports = [port_for(source, offsets[:source]), port_for(target, offsets[:target])]
+          return {} unless ports.all?
+
+          { source_port: point_for(ports.first), target_port: point_for(ports.last),
+            source_anchor: stored_ray_origin(source, geom[:sx], geom[:sy]),
+            target_anchor: stored_ray_origin(target, geom[:ex], geom[:ey]),
+            has_geometry_offsets: true }
+        end
+
+        def point_for(pair)
+          Ea::Model::Point.new(x: pair[0], y: pair[1])
+        end
+
         # Placements here are already Ea::Model::Bounds.
         def bounds_from_rect(bounds)
           bounds

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

@@ -9,6 +9,7 @@ module Ea
       # connector passes over a crossing.
       class ConnectorBridges
         RADIUS = 6
+        PHANTOM = :phantom
 
         def initialize(_diagram, routes)
           @routes = routes.map { |connector, points| [connector, points, priority_for(connector)] }
@@ -56,78 +57,75 @@ module Ea
 
         # nil or empty: no bridge decision for this connector.
         def priority_for(connector)
+          return PHANTOM if phantom?(connector)
+
           connector.paint_order if connector.paint_order&.any?
         end
 
-        def crossings_for(connector, priority, first, last)
-          axis = axis_for(first, last)
-          return [] unless axis
+        # A phantom (relationship without a link row) has no stored order; it
+        # is appended after every link in the export, so it passes over them.
+        def phantom?(connector)
+          connector.paint_order.nil?
+        end
 
+        def crossings_for(connector, priority, first, last)
           crossings = lower_routes(connector, priority).flat_map do |_partner, points, _order|
             points.each_cons(2).filter_map do |start, finish|
-              crossing(first, last, start, finish, axis)
+              crossing(first, last, start, finish)
             end
           end
-          separate_crossings(crossings, axis).sort_by { |point| (point[axis] - first[axis]).abs }
+          separate_crossings(crossings, first, last).sort_by { |point| distance(point, first) }
         end
 
         # The order key is only proven across different start placements, so
         # connectors leaving the same placement make no carrier decision.
         def lower_routes(connector, priority)
+          return keyed_routes(connector) if priority == PHANTOM
+
           @routes.select do |partner, _points, order|
-            !partner.equal?(connector) && order && order.size == priority.size &&
+            !partner.equal?(connector) && order.is_a?(Array) && order.size == priority.size &&
               !same_source?(connector, partner) && (order <=> priority).negative?
           end
         end
 
+        def keyed_routes(connector)
+          @routes.select { |partner, _points, order| !partner.equal?(connector) && order.is_a?(Array) }
+        end
+
         def same_source?(connector, partner)
           connector.source_element_ref && connector.source_element_ref == partner.source_element_ref
         end
 
-        # Suppress both overlapping spans, including coincident crossings,
-        # so route order cannot select one of several ambiguous arcs.
-        def separate_crossings(crossings, axis)
-          crossings.reject.with_index do |point, index|
-            crossings.each_with_index.any? do |other, other_index|
-              index != other_index && (point[axis] - other[axis]).abs < 2 * RADIUS
-            end
+        # Partners crossing at one point share a single arc (0BE81AC5 draws one
+        # arc for three coincident verticals). Distinct crossings whose spans
+        # overlap are all suppressed so route order cannot select one of
+        # several ambiguous arcs.
+        def separate_crossings(crossings, first, last)
+          crossings = crossings.uniq { |point| point.map { |value| value.round(6) } }
+          axis = SegmentGeometry.dominant_axis(first, last)
+          spans = crossings.map do |point|
+            SegmentGeometry.chord(first, last, point, RADIUS).map { |seat| seat[axis] }.minmax
           end
+          crossings.reject.with_index { |_point, index| overlapping_span?(spans, index) }
         end
 
-        def crossing(first, last, start, finish, axis)
-          return unless axis_for(start, finish) == 1 - axis
-
-          point = axis.zero? ? [start[0], first[1]] : [first[0], start[1]]
-          return unless segment_interior?(point, first, last, axis) &&
-                        segment_interior?(point, start, finish, 1 - axis)
-
-          point
-        end
-
-        def segment_interior?(point, first, last, axis)
-          interior?(point[axis], first[axis], last[axis])
+        def overlapping_span?(spans, index)
+          minimum, maximum = spans[index]
+          spans.each_with_index.any? do |(other_minimum, other_maximum), other_index|
+            index != other_index && minimum < other_maximum && other_minimum < maximum
+          end
         end
 
-        def interior?(value, first, last)
-          minimum, maximum = [first, last].minmax
-          value > minimum && value < maximum &&
-            value - minimum >= RADIUS && maximum - value >= RADIUS
+        def crossing(first, last, start, finish)
+          SegmentGeometry.crossing(first, last, start, finish, RADIUS)
         end
 
-        def axis_for(first, last)
-          return 0 if first[1] == last[1] && first[0] != last[0]
-          return 1 if first[0] == last[0] && first[1] != last[1]
-
-          nil
+        def distance(point, other)
+          SegmentGeometry.distance(point, other)
         end
 
         def arc_commands(first, last, crossing)
-          axis = axis_for(first, last)
-          direction = last[axis] > first[axis] ? 1 : -1
-          start = crossing.dup
-          finish = crossing.dup
-          start[axis] -= direction * RADIUS
-          finish[axis] += direction * RADIUS
+          start, finish = SegmentGeometry.chord(first, last, crossing, RADIUS)
           ["L #{coordinates(start)}", "A #{RADIUS} #{RADIUS} 180 0 0 #{coordinates(finish)}"]
         end
 

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

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

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

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

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

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

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Segment arithmetic for connector bridges: where two segments cross at
+      # any slope, and where the arc chord sits on the carrier segment.
+      module SegmentGeometry
+        EPSILON = 1e-9
+
+        module_function
+
+        def distance(point, other)
+          Math.hypot(point[0] - other[0], point[1] - other[1])
+        end
+
+        # 0 for a horizontal segment, 1 for a vertical one, nil otherwise.
+        def axis_for(first, last)
+          return 0 if first[1] == last[1] && first[0] != last[0]
+          return 1 if first[0] == last[0] && first[1] != last[1]
+
+          nil
+        end
+
+        # A proper crossing of two segments; parallel and collinear segments
+        # never cross. Each span must leave `radius` of room either side.
+        def crossing(first, last, start, finish, radius)
+          point = axis_crossing(first, last, start, finish) ||
+                  slanted_crossing(first, last, start, finish)
+          return unless point && room?(point, first, last, radius) && room?(point, start, finish, radius)
+          return unless chord_fits?(first, last, point, radius)
+
+          point
+        end
+
+        # The arc chord, one radius either side of the crossing along the
+        # carrier's dominant axis. A horizontal/vertical carrier keeps the
+        # exact crossing. On a slanted carrier EA seats the centre on the
+        # integer grid at floor(crossing) and offsets it by the half-chord
+        # (radius, truncated radius * slope), signed with the line direction.
+        def chord(first, last, crossing, radius)
+          major = dominant_axis(first, last)
+          step = last[major] > first[major] ? radius : -radius
+          return axis_chord(first, crossing, major, step) if first[1 - major] == last[1 - major]
+
+          slanted_chord(first, last, crossing, major, step)
+        end
+
+        def slanted_chord(first, last, crossing, major, step)
+          centre = crossing.map { |value| (value + EPSILON).floor }
+          half = half_chord(first, last, major, step)
+          [-1, 1].map { |sign| centre.zip(half).map { |c, h| c + sign * h } }
+        end
+
+        def half_chord(first, last, major, step)
+          minor = 1 - major
+          slope = (last[minor] - first[minor]).fdiv(last[major] - first[major])
+          major.zero? ? [step, (step * slope).truncate] : [(step * slope).truncate, step]
+        end
+
+        def axis_chord(first, crossing, major, step)
+          start = crossing.dup
+          finish = crossing.dup
+          start[1 - major] = finish[1 - major] = first[1 - major]
+          start[major] -= step
+          finish[major] += step
+          [start, finish]
+        end
+
+        # Integer seating must not extend the decorated carrier past an end.
+        def chord_fits?(first, last, point, radius)
+          chord(first, last, point, radius).all? do |seat|
+            [0, 1].all? { |axis| within?(seat[axis], first[axis], last[axis]) }
+          end
+        end
+
+        def dominant_axis(first, last)
+          (last[0] - first[0]).abs >= (last[1] - first[1]).abs ? 0 : 1
+        end
+
+        def axis_crossing(first, last, start, finish)
+          axis = axis_for(first, last)
+          return unless axis && axis_for(start, finish) == 1 - axis
+
+          axis.zero? ? [start[0], first[1]] : [first[0], start[1]]
+        end
+
+        def slanted_crossing(first, last, start, finish)
+          return if axis_for(first, last) && axis_for(start, finish)
+
+          direction = delta(first, last)
+          other = delta(start, finish)
+          denominator = cross(direction, other)
+          return if denominator.zero?
+
+          advance(first, direction, cross(delta(first, start), other).fdiv(denominator))
+        end
+
+        def advance(origin, direction, fraction)
+          [origin[0] + fraction * direction[0], origin[1] + fraction * direction[1]]
+        end
+
+        def delta(from, to)
+          [to[0] - from[0], to[1] - from[1]]
+        end
+
+        def cross(one, other)
+          one[0] * other[1] - one[1] * other[0]
+        end
+
+        def room?(point, first, last, radius)
+          distance(point, first) >= radius && distance(point, last) >= radius &&
+            [0, 1].all? { |axis| within?(point[axis], first[axis], last[axis]) }
+        end
+
+        def within?(value, from, to)
+          minimum, maximum = [from, to].minmax
+          value >= minimum - EPSILON && value <= maximum + EPSILON
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -33,6 +33,8 @@ module Ea
       autoload :Connectors, "ea/svg/ea_emitter/connectors"
       autoload :ConnectorBridges, "ea/svg/ea_emitter/connector_bridges"
       private_constant :ConnectorBridges
+      autoload :SegmentGeometry, "ea/svg/ea_emitter/segment_geometry"
+      private_constant :SegmentGeometry
       autoload :Markers, "ea/svg/ea_emitter/markers"
       autoload :Labels, "ea/svg/ea_emitter/labels"
       autoload :GhostLabels, "ea/svg/ea_emitter/ghost_labels"

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.137"
+  VERSION = "0.6.139"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.137
+  version: 0.6.139
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -857,6 +857,7 @@ files:
 - 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/diagram_builder/umldi_edges/property_roles.rb
 - lib/ea/sources/xmi/extension_elements.rb
 - lib/ea/sources/xmi/extension_geometry_parser.rb
 - lib/ea/sources/xmi/extension_style_parser.rb
@@ -976,6 +977,7 @@ files:
 - lib/ea/svg/ea_emitter/markers.rb
 - lib/ea/svg/ea_emitter/orthogonal_ray.rb
 - lib/ea/svg/ea_emitter/render_context.rb
+- lib/ea/svg/ea_emitter/segment_geometry.rb
 - lib/ea/svg/ea_emitter/style.rb
 - lib/ea/svg/ea_emitter/text_renderer.rb
 - lib/ea/svg/ea_emitter/visibility_symbol.rb