ea 0.6.29 → 0.6.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 521d4fdcc042ad06bd18a829f39810ccef7df8f750bbe229c6d7c38ea3e45c2e
-  data.tar.gz: 49f8e753ae47eda15409252023e894e66949e590c579c9da7fb4140acc74e550
+  metadata.gz: da25cfb5a4f0690b2b73df2d3c12fe3cd042c96fe6aab67d07e2c8871868feaf
+  data.tar.gz: 8be40d4bb501b904f1ba2609446d332ea260f3d04a831528d213d6747e352dfa
 SHA512:
-  metadata.gz: 151b418a45c19c998c41957ddb471127f6e110689372a01e046152024c271b10ccb069af527c877ee6404cfe22c0323f55232e9140ba5a4882b382534a26b4b6
-  data.tar.gz: d2b597bfebed6432a78285f8898d73ef6cfdbbf65362132eed375b387bdc0aa1cfb40ceddabea22695060b8467e70c94768618b7a102bca556f0ab5351882955
+  metadata.gz: 271180e45139ae7e67a63a66a9fd78c8311edd379ee73f3a5ab9241f7b43d1be737bffca276e0585473f0294f1f557d3ff46fb254cdd105b8b6526ffb052fd36
+  data.tar.gz: 63856efa026109bf92d89468c10e6325f9a2f411e4f49217335667b590842d1b5f8f0f860f17c3527bb57236a3d096729ae411a9c3166c4f4efbb169db30eea0

data/lib/ea/sources/qea/context_diagram_support.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # EA AUTO-GENERATED "Context Diagram" support.
+      #
+      # Context diagrams are regenerated by EA at DRAW time from the
+      # model, so the stored t_diagramlinks rows are stale:
+      #
+      #   - Hidden rows are NEVER drawn (B6847577: 42 Hidden=1
+      #     dependencies, zero rendered).
+      #   - Every drawn connector is a DIRECT line: the straight
+      #     segment between the two box-outline crossings of the
+      #     center-to-center ray (verified: B6847577 focal left-edge
+      #     dock predicted 171.8 vs EA 171; E58034A3's 22 visible
+      #     links all render straight despite stale EDGE geometry).
+      #   - Package contexts ("Context Diagram: Package
+      #     Clients|Suppliers of X") synthesize ONE extra line per
+      #     placed object carrying a model Dependency with the focal
+      #     package X, unless a visible link already connects the
+      #     pair (B6847577: 15 synthesized + 2 visible = 17 drawn).
+      #     When the focal is not placed exactly once, nothing
+      #     synthesizes (E02FA330: 7 placed suppliers, 0 lines).
+      module ContextDiagramSupport
+        NAME_PREFIX = "context diagram"
+        PACKAGE_PATTERN = /\AContext Diagram: Package (Clients|Suppliers) of (.+)\z/i
+        FOCAL_CONNECTOR_TYPES = %w[Dependency].freeze
+
+        module_function
+
+        def context?(diagram_row)
+          diagram_row.name.to_s.downcase.start_with?(NAME_PREFIX)
+        end
+
+        # {"variant" => "Clients"|"Suppliers", "focal_name" => X}
+        # for package contexts, nil otherwise.
+        def package_context(diagram_row)
+          match = PACKAGE_PATTERN.match(diagram_row.name.to_s)
+          return nil unless match
+
+          # The name after "of " is matched VERBATIM: EA stores
+          # object names with their own whitespace ("of  Topology
+          # Simple" pairs the object " Topology Simple").
+          { "variant" => match[1].capitalize, "focal_name" => match[2] }
+        end
+
+        # Placed-object rows for the focal package (exact name match),
+        # or [] — callers synthesize only when exactly one exists.
+        def focal_placements(diagram_row, database)
+          pkg = package_context(diagram_row)
+          return [] unless pkg
+
+          placements = database.diagram_objects_for(diagram_row.diagram_id) || []
+          placements.select do |placement|
+            obj = database.find_object(placement.ea_object_id.to_i)
+            obj && obj.name.to_s == pkg["focal_name"]
+          end
+        end
+
+        # EA object IDs of placed elements that carry a model
+        # Dependency with the focal package, minus pairs already
+        # connected by a visible link row.
+        def autoline_candidates(diagram_row, database)
+          pkg = package_context(diagram_row)
+          return {} unless pkg
+
+          focal_rows = focal_placements(diagram_row, database)
+          return {} unless focal_rows.size == 1
+
+          focal_id = focal_rows.first.ea_object_id.to_i
+          placed_ids = placed_object_ids_for(diagram_row, database)
+          visible = visible_focal_partners(diagram_row, database, focal_id)
+
+          into_focal = pkg["variant"] == "Clients"
+          candidates = {}
+          (database.collections[:connectors] || []).each do |conn|
+            next unless FOCAL_CONNECTOR_TYPES.include?(conn.connector_type)
+
+            start_id = conn.start_object_id.to_i
+            end_id = conn.end_object_id.to_i
+            other = if into_focal && end_id == focal_id
+                      start_id
+                    elsif !into_focal && start_id == focal_id
+                      end_id
+                    end
+            next unless other
+            next unless placed_ids.include?(other)
+            next if visible.include?(other)
+
+            candidates[other] ||= conn
+          end
+          candidates
+        end
+
+        # SuppressFOC=1 in t_diagram.StyleEx freezes an element
+        # context diagram to its stored visible links; absent or 0
+        # makes EA regenerate ALL model connectors among the placed
+        # elements (568CDFC9 draws all 10 incl. hidden rows'
+        # connectors; 3072804C/801EEB12 with =1 draw visible rows
+        # only).
+        def element_regenerate?(diagram_row)
+          return false if package_context(diagram_row)
+
+          diagram_row.styleex.to_s.match(/SuppressFOC=(\d)/)&.public_send(:[], 1) != "1"
+        end
+
+        # t_connector rows EA regenerates for a SuppressFOC=0 element
+        # context: connectors among the placed elements that touch
+        # the focal, plus "star" links joining a focal neighbour to a
+        # non-neighbour (E0790EFC draws the 8 focal links and skips
+        # the ring1-ring1 web; 85039DAE draws ring2-ring1 and skips
+        # ring2-ring2). Ring1-ring1 links never draw. Self-loops of
+        # the focal included. Hidden rows do not block regeneration;
+        # visible rows keep their stored rendering instead.
+        def regenerated_element_connectors(diagram_row, database)
+          return [] unless element_regenerate?(diagram_row)
+
+          placed_ids = placed_object_ids_for(diagram_row, database)
+          visible_conn_ids = (database.diagram_links_for(diagram_row.diagram_id) || [])
+                             .reject { |link| link.hidden.to_i.nonzero? }
+                             .map(&:connectorid).compact.to_set
+          focal_id = focal_element_id(diagram_row, database, placed_ids)
+          neighbours = focal_neighbours(database, focal_id)
+          (database.collections[:connectors] || []).filter_map do |conn|
+            next nil if conn.connector_type == "Nesting"
+            next nil unless placed_ids.include?(conn.start_object_id.to_i)
+            next nil unless placed_ids.include?(conn.end_object_id.to_i)
+            next nil if visible_conn_ids.include?(conn.connector_id)
+            next nil unless regenerated_pair?(conn, focal_id, neighbours)
+
+            conn
+          end
+        end
+
+        def focal_element_id(diagram_row, database, placed_ids)
+          focal_name = diagram_row.name.to_s
+                              .sub(/\AContext [Dd]iagram:\s*/, "")
+                              .strip
+          focal = (database.diagram_objects_for(diagram_row.diagram_id) || [])
+                  .select do |placement|
+            obj = database.find_object(placement.ea_object_id.to_i)
+            obj && obj.name.to_s == focal_name
+          end
+          return focal.first.ea_object_id.to_i if focal.size == 1
+
+          # Renamed focus: EA keeps drawing the original element's
+          # context ("Context Diagram: TS_Feature" still renders the
+          # TS_FeatureComponent star after the rename). Fall back to
+          # the placed element most connected WITHIN the placed set
+          # (global model degree is misleading — GM_Composite links
+          # to hundreds of off-diagram elements).
+          degree = Hash.new(0)
+          (database.collections[:connectors] || []).each do |conn|
+            start_id = conn.start_object_id.to_i
+            end_id = conn.end_object_id.to_i
+            next unless placed_ids.include?(start_id) &&
+                        placed_ids.include?(end_id)
+
+            degree[start_id] += 1
+            degree[end_id] += 1
+          end
+          placed_ids.max_by { |id| [degree[id], -id] }
+        end
+
+        def focal_neighbours(database, focal_id)
+          return Set.new unless focal_id
+
+          neighbours = Set.new
+          (database.collections[:connectors] || []).each do |conn|
+            next if conn.connector_type == "Nesting"
+
+            neighbours << conn.end_object_id.to_i if conn.start_object_id.to_i == focal_id
+            neighbours << conn.start_object_id.to_i if conn.end_object_id.to_i == focal_id
+          end
+          neighbours
+        end
+
+        def regenerated_pair?(conn, focal_id, neighbours)
+          return false unless focal_id
+
+          start_id = conn.start_object_id.to_i
+          end_id = conn.end_object_id.to_i
+          return true if start_id == focal_id || end_id == focal_id
+
+          (neighbours.include?(start_id) ? 1 : 0) +
+            (neighbours.include?(end_id) ? 1 : 0) == 1
+        end
+
+        def placed_object_ids_for(diagram_row, database)
+          (database.diagram_objects_for(diagram_row.diagram_id) || [])
+            .map { |p| p.ea_object_id.to_i }
+        end
+
+        # Object IDs whose pair with the focal is already drawn by a
+        # visible link row (connector exists, both ends placed).
+        def visible_focal_partners(diagram_row, database, focal_id)
+          placed_ids = placed_object_ids_for(diagram_row, database)
+          partners = []
+          (database.diagram_links_for(diagram_row.diagram_id) || []).each do |link|
+            next if link.hidden.to_i.nonzero?
+
+            conn = database.find_connector(link.connectorid)
+            next unless conn
+
+            start_id = conn.start_object_id.to_i
+            end_id = conn.end_object_id.to_i
+            next unless placed_ids.include?(start_id) && placed_ids.include?(end_id)
+            next unless start_id == focal_id || end_id == focal_id
+
+            partners << (start_id == focal_id ? end_id : start_id)
+          end
+          partners
+        end
+      end
+    end
+  end
+end

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

@@ -130,11 +130,116 @@ module Ea
 
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
+          context = ContextDiagramSupport.context?(diagram_row)
+          # EA regenerates context diagrams at draw time; their
+          # Hidden link rows are stale and never render.
+          links = links.reject { |link_row| hidden?(link_row) } if context
           explicit = links.map { |link_row| build_connector(link_row, diagram_row) }
-          phantom = phantom_connectors(diagram_row, explicit)
+          explicit += if ContextDiagramSupport.package_context(diagram_row)
+                        context_autolines(diagram_row)
+                      else
+                        regenerated_element_connectors(diagram_row)
+                      end
+          # EA does not phantom-synthesize on context diagrams — it
+          # regenerates instead (3072804C: phantoms doubled the
+          # drawn arrows until disabled).
+          phantom = context ? [] : phantom_connectors(diagram_row, explicit)
           explicit + phantom
         end
 
+        # SuppressFOC=0 element contexts regenerate every model
+        # connector among the placed elements; only the visible rows
+        # carry stored geometry, the rest synthesize direct routes.
+        def regenerated_element_connectors(diagram_row)
+          ContextDiagramSupport
+            .regenerated_element_connectors(diagram_row, database)
+            .each_with_index.map do |conn, idx|
+              build_regenerated_connector(conn, diagram_row, idx)
+            end.compact
+        end
+
+        def build_regenerated_connector(conn, diagram_row, idx)
+          source_id = conn.start_object_id.to_i
+          target_id = conn.end_object_id.to_i
+          source = diagram_object_placement(diagram_row.diagram_id, source_id)
+          target = diagram_object_placement(diagram_row.diagram_id, target_id)
+          return nil unless source && target
+
+          source_bounds = bounds_from_rect(source)
+          target_bounds = bounds_from_rect(target)
+          waypoints = if source_id == target_id
+                        self_loop_waypoints(source_bounds)
+                      else
+                        direct_waypoints(source_bounds, target_bounds)
+                      end
+          Ea::Model::DiagramConnector.new(
+            id: IdNormalizer.synthetic("ec", diagram_row.diagram_id, idx),
+            diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
+            relationship_ref: ref_for_raw_connector(conn),
+            connector_type: conn.connector_type,
+            direction: conn.direction,
+            source_stereotype: conn.sourcestereotype,
+            target_stereotype: conn.deststereotype,
+            waypoints: waypoints,
+            label_boxes: {},
+            style: { direct: true },
+            hidden: false,
+            has_geometry_offsets: false
+          )
+        end
+
+        # EA's regenerated self-loop: a small elbow exiting and
+        # re-entering the box's right edge (568CDFC9: 30px out,
+        # 15px tall, centered on the box's vertical middle).
+        SELF_LOOP_OUT = 30
+        SELF_LOOP_TALL = 15
+
+        def self_loop_waypoints(bounds)
+          right = bounds.x + bounds.width
+          cy = bounds.y + (bounds.height / 2)
+          pts = [[right, cy + SELF_LOOP_TALL / 2.0],
+                 [right + SELF_LOOP_OUT, cy + SELF_LOOP_TALL / 2.0],
+                 [right + SELF_LOOP_OUT, cy - SELF_LOOP_TALL / 2.0],
+                 [right, cy - SELF_LOOP_TALL / 2.0]]
+          pts.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
+        end
+
+        # Package context diagrams synthesize one Dependency line per
+        # placed client/supplier of the focal package that has no
+        # visible link row connecting it (see ContextDiagramSupport).
+        def context_autolines(diagram_row)
+          ContextDiagramSupport.autoline_candidates(diagram_row, database)
+                               .map { |object_id, conn| context_autoline(conn, diagram_row, object_id) }
+                               .compact
+        end
+
+        def context_autoline(conn, diagram_row, object_id)
+          focal = ContextDiagramSupport.focal_placements(diagram_row, database).first
+          return nil unless focal
+
+          into_focal = ContextDiagramSupport.package_context(diagram_row)["variant"] == "Clients"
+          source_id = into_focal ? object_id : focal.ea_object_id.to_i
+          target_id = into_focal ? focal.ea_object_id.to_i : object_id
+          source_placement = diagram_object_placement(diagram_row.diagram_id, source_id)
+          target_placement = diagram_object_placement(diagram_row.diagram_id, target_id)
+          return nil unless source_placement && target_placement
+
+          source_bounds = bounds_from_rect(source_placement)
+          target_bounds = bounds_from_rect(target_placement)
+          waypoints = direct_waypoints(source_bounds, target_bounds)
+          Ea::Model::DiagramConnector.new(
+            id: IdNormalizer.synthetic("xc", diagram_row.diagram_id, object_id),
+            diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
+            relationship_ref: ref_for_raw_connector(conn),
+            connector_type: conn.connector_type,
+            waypoints: waypoints,
+            label_boxes: {},
+            style: { direct: true },
+            hidden: false,
+            has_geometry_offsets: false
+          )
+        end
+
         # EA renders PHANTOM CONNECTORS for associations that exist
         # in t_connector between two elements BOTH placed on the
         # current diagram, even when no t_diagramlinks entry exists
@@ -142,10 +247,15 @@ module Ea
         # renders as a straight line between the two element edges,
         # with SourceRole labels and appropriate markers.
         #
-        # Only Association and Aggregation types produce phantom
-        # connectors. Generalization, Dependency, and Package types
-        # do NOT get phantom rendering.
-        PHANTOM_CONNECTOR_TYPES = %w[Association Aggregation].freeze
+        # Dependency AND Generalization phantoms draw: Main/
+        # 9FCDB717 renders 12 of 13 model dependencies among the
+        # placed packages (the 13th suppressed by the diagram's
+        # single Hidden link row); All/F209CE4B renders all 11
+        # row-less generalizations as white triangles. A Hidden
+        # link row suppresses; absence of a row does not.
+        PHANTOM_CONNECTOR_TYPES = %w[Association Aggregation Dependency
+                                     Generalization].freeze
+        PHANTOM_DOUBLE_BACK_TYPES = %w[Dependency].freeze
 
         def phantom_connectors(diagram_row, explicit_connectors)
           placed_ids = placed_object_ids_on(diagram_row.diagram_id)
@@ -203,7 +313,7 @@ module Ea
             target_stereotype: conn.deststereotype,
             waypoints: waypoints,
             label_boxes: DEFAULT_LABEL_BOXES,
-            style: {},
+            style: PHANTOM_DOUBLE_BACK_TYPES.include?(conn.connector_type) ? { direct: true } : {},
             hidden: false,
             has_geometry_offsets: false
           )
@@ -235,6 +345,8 @@ module Ea
         def build_connector(link_row, diagram_row)
           connector = database.find_connector(link_row.connectorid)
           geom = parse_geometry_fields(link_row.geometry)
+          context = ContextDiagramSupport.package_context(diagram_row) ||
+                    ContextDiagramSupport.element_regenerate?(diagram_row)
           Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic("dc", diagram_row.diagram_id,
                                        link_row.instance_id),
@@ -244,17 +356,45 @@ module Ea
             direction: connector&.direction,
             source_stereotype: connector&.sourcestereotype,
             target_stereotype: connector&.deststereotype,
-            waypoints: waypoints_for_link(link_row, diagram_row),
+            waypoints: context ? context_waypoints_for(connector, diagram_row) :
+                         waypoints_for_link(link_row, diagram_row),
             source_port: connection_port(diagram_row, connector, :source, geom),
             target_port: connection_port(diagram_row, connector, :target, geom),
-            label_boxes: geom[:label_boxes] || {},
-            style: DiagramStyleParser.parse(link_row.style),
+            label_boxes: context ? {} : (geom[:label_boxes] || {}),
+            style: context ? { direct: true } :
+                     DiagramStyleParser.parse(link_row.style),
             hidden: hidden?(link_row),
             ghost_labels: ghost_labels_for(connector, diagram_row, link_row),
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry)
           )
         end
 
+        # Context diagrams re-route every drawn connector as a
+        # direct line at draw time: the center-to-center ray clipped
+        # at both box outlines. The stored SX/SY/EDGE geometry is
+        # stale on these diagrams (corpus-verified E58034A3: 22
+        # visible links render straight despite EDGE= geometry).
+        def context_waypoints_for(connector, diagram_row)
+          return [] unless connector
+
+          source = diagram_object_placement(diagram_row.diagram_id,
+                                            connector.start_object_id)
+          target = diagram_object_placement(diagram_row.diagram_id,
+                                            connector.end_object_id)
+          return [] unless source && target
+
+          direct_waypoints(bounds_from_rect(source), bounds_from_rect(target))
+        end
+
+        # Straight-line waypoints between the two box-outline
+        # crossings of the center-to-center ray.
+        def direct_waypoints(source_bounds, target_bounds)
+          s = bounds_edge_point(source_bounds, target_bounds)
+          t = bounds_edge_point(target_bounds, source_bounds)
+          [Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: s[0], y: s[1])),
+           Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: t[0], y: t[1]))]
+        end
+
         # EA's t_diagramlinks.Geometry may carry explicit SX/SY/EX/EY
         # offset fields (even zeros) OR omit them entirely. The
         # presence of SX= gates the «import» package_anchor marker:

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

@@ -62,9 +62,8 @@ module Ea
             target_multiplicity_upper: parse_upper(row.destcard),
             source_multiplicity_raw: raw_card(row.sourcecard),
             target_multiplicity_raw: raw_card(row.destcard),
-            source_aggregation: ConnectorRelationshipMap
-                                .source_aggregation_for(row.connector_type),
-            target_aggregation: aggregation_from(row.destaccess),
+            source_aggregation: source_aggregation_for(row),
+            target_aggregation: aggregation_from(row.destisaggregate),
             source_navigable: navigable?(row.sourceaccess, row.direction,
                                          :source),
             target_navigable: navigable?(row.destaccess, row.direction, :target)
@@ -112,15 +111,27 @@ module Ea
           end
         end
 
-        def aggregation_from(access_value)
-          case access_value.to_s
-          when "0" then "none"
-          when "1" then "shared"
-          when "2" then "composite"
+        # EA stores the aggregate end in t_connector.SourceIsAggregate/
+        # DestIsAggregate (0 none, 1 shared, 2 composite) — NOT in
+        # DestAccess, which carries the accessibility string
+        # ("Public"). The connector TYPE only implies a source-side
+        # aggregation when the flags are silent (legacy
+        # Connector_Type encoding).
+        def aggregation_from(flag_value)
+          case flag_value.to_i
+          when 1 then "shared"
+          when 2 then "composite"
           else "none"
           end
         end
 
+        def source_aggregation_for(row)
+          flagged = aggregation_from(row.sourceisaggregate)
+          return flagged if flagged != "none"
+
+          ConnectorRelationshipMap.source_aggregation_for(row.connector_type)
+        end
+
         def navigable?(_access, direction, end_label)
           # EA's navigability is messy. Treat unspecified direction
           # as bidirectional, "Source -> Destination" as target-only

data/lib/ea/sources/qea.rb

@@ -27,6 +27,7 @@ module Ea
       autoload :InstanceBuilder, "ea/sources/qea/instance_builder"
       autoload :LegendBuilder, "ea/sources/qea/legend_builder"
       autoload :DiagramBuilder, "ea/sources/qea/diagram_builder"
+      autoload :ContextDiagramSupport, "ea/sources/qea/context_diagram_support"
       autoload :DiagramStyleParser, "ea/sources/qea/diagram_style_parser"
       autoload :Xref, "ea/sources/qea/xref"
       autoload :Adapter, "ea/sources/qea/adapter"

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

@@ -62,9 +62,22 @@ module Ea
             x, y = translate_point(p)
             "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
           end.join(" ")
+          # EA writes a trailing zero-length "M <start>" repeat for
+          # DIRECT (auto-routed straight) connectors — verified on
+          # context diagrams where every line carries it (B6847577,
+          # E58034A3, 8CF27BE8).
+          if pts.size == 2 && direct?(connector)
+            x, y = translate_point(pts.first)
+            d = "#{d} M #{Canvas.coord(x)} #{Canvas.coord(y)}"
+          end
           %(<path d="#{d}" shape-rendering="auto"/>)
         end
 
+        def direct?(connector)
+          style = connector.style || {}
+          style.key?(:direct) || style.key?("direct")
+        end
+
         def waypoints_for(connector)
           (connector.waypoints || []).filter_map do |wp|
             next unless wp.position

data/lib/ea/svg/ea_emitter/marker/arrow_path.rb

@@ -16,6 +16,15 @@ module Ea
 
           def self.specs_for(connector, source, target, before_target,
                              after_source, relationship: nil)
+            # EA draws the navigability arrow on directed
+            # associations AND aggregations (333EFCCF: 6 aggregations
+            # render diamond + path arrow); Direction
+            # "Unspecified"/empty draws a plain line (EC670ED5: the
+            # single Unspecified association is arrowless;
+            # C852CC42/TransferNode: 9 Unspecified all arrowless).
+            direction = connector.direction.to_s
+            return [] if direction.empty? || direction == "Unspecified"
+
             return bidirectional_specs(source, target, before_target,
                                        after_source) if bidirectional?(connector)
 

data/lib/ea/svg/ea_emitter/marker/diamond.rb

@@ -4,49 +4,59 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # Diamond marker at the whole end of an aggregation or
-        # composition, PLUS a navigability arrow at the part end
-        # when the connector's direction is "Destination -> Source".
-        # Reference SVGs confirm EA emits BOTH markers for
-        # reverse-direction aggregations on the plateau: the diamond
-        # distinguishes aggregation from association, the arrow shows
-        # navigability direction. Forward-direction ("Source ->
-        # Destination") aggregations get the diamond only — verified
-        # against basic.qea's "Two Level Class Composition Hierarchy"
-        # diagram, where the reference SVG has 17 diamonds and 0
-        # arrows.
+        # Diamond marker at the whole end of an aggregation, plus a
+        # navigability arrow apexing at the diamond's line-side tip.
+        #
+        # WHOLE-END SELECTION: EA flags the whole end either through
+        # t_connector.DestAccess (1 shared / 2 composite -> whole at
+        # the TARGET; corpus-verified 333EFCCF: PersonalRight_E is
+        # the DestAccess=2 end and every diamond sits there) or
+        # through the Connector_Type itself ("Aggregation"/
+        # "Composition" -> whole at the SOURCE; basic.qea's
+        # composition diagram). DestAccess wins when both appear.
+        # Without relationship data the direction heuristic applies
+        # ("Destination -> Source" -> whole at target).
+        #
+        # ARROW: dest-flagged aggregations draw a base-12 height-15
+        # open arrow stacked on the diamond tip pointing into the
+        # whole (333EFCCF: 6 diamonds + 6 path arrows). Type-inferred
+        # source-side aggregations draw the diamond only (basic.qea:
+        # 17 diamonds, 0 arrows).
         class Diamond < Kind
           def self.handles?(effective_type)
             effective_type == "Aggregation" || effective_type == "Composition"
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
-            whole_end_at_source = whole_end_at_source?(connector)
-            whole_anchor = whole_end_at_source ? source : target
-            whole_base = whole_end_at_source ? after_source : before_target
+            whole_at_target = whole_at_target?(connector, relationship)
+            whole_anchor = whole_at_target ? target : source
+            whole_base = whole_at_target ? before_target : after_source
             specs = [Registry::Spec.new(shape: :diamond,
                                         anchor: whole_anchor,
                                         base: whole_base)]
-            return specs unless navigable_part_end?(connector)
+            return specs unless whole_at_target
 
-            part_anchor = whole_end_at_source ? target : source
-            part_base = whole_end_at_source ? before_target : after_source
             specs << Registry::Spec.new(shape: :arrow,
-                                        anchor: part_anchor,
-                                        base: part_base)
+                                        anchor: whole_anchor,
+                                        base: whole_base)
             specs
           end
 
-          # EA renders the navigability arrow at the part end of an
-          # aggregation only when the connector's direction is
-          # "Destination -> Source" — the conventional EA encoding
-          # for "part -> whole" with navigability back to the whole.
-          # Forward-direction aggregations ("Source -> Destination")
-          # omit the arrow: the diamond already communicates the
-          # aggregation semantic and the destination is not
-          # explicitly navigable.
-          def self.navigable_part_end?(connector)
-            connector.direction == "Destination -> Source"
+          def self.whole_at_target?(connector, relationship)
+            return true if dest_flagged?(relationship)
+            return false if source_flagged?(relationship)
+
+            !whole_end_at_source?(connector)
+          end
+
+          def self.dest_flagged?(relationship)
+            relationship &&
+              %w[shared composite].include?(relationship.target_aggregation.to_s)
+          end
+
+          def self.source_flagged?(relationship)
+            relationship &&
+              %w[shared composite].include?(relationship.source_aggregation.to_s)
           end
         end
       end

data/lib/ea/svg/ea_emitter/marker/open_triangle.rb

@@ -14,14 +14,19 @@ module Ea
         # the diagram's generalizations use polygons.
         class OpenTriangle < Kind
           def self.handles?(effective_type)
-            %w[Generalization Realization Dependency].include?(effective_type)
+            %w[Generalization Realization Realisation Dependency
+               InformationFlow NoteLink].include?(effective_type)
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
             whole_end_at_source = whole_end_at_source?(connector)
             anchor = whole_end_at_source ? target : source
             base = whole_end_at_source ? before_target : after_source
-            shape = effective_type?(connector) == "Dependency" ? :arrow : :triangle
+            shape = if %w[Dependency InformationFlow].include?(effective_type?(connector))
+                    :dependency_arrow
+                  else
+                    :triangle
+                  end
             [Registry::Spec.new(shape: shape, anchor: anchor, base: base)]
           end
 

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

@@ -21,8 +21,15 @@ module Ea
         DIAMOND_HALF_H = 10
         TRI_HALF_BASE = 6
         TRI_HEIGHT = 11
+        # EA's path arrowheads are height 15 corpus-wide, with
+        # distinct bases per connector kind: association
+        # navigability arrows base 12, dependency arrows base 10
+        # (measured across E58034A3/8CF27BE8 context diagrams and
+        # 46217EA4/C2B04372/7A3B5001 dependency figures).
         ARROW_HALF_BASE = 6
-        ARROW_HEIGHT = 11
+        ARROW_HEIGHT = 15
+        DEP_ARROW_HALF_BASE = 5
+        DEP_ARROW_HEIGHT = 15
 
         attr_reader :diagram, :model_index, :canvas, :grouped, :stroke_width
 
@@ -109,6 +116,10 @@ module Ea
             style_key: :connector_line,
             render: ->(m, anchor, base) { m.arrow_path(anchor, base) }
           },
+          dependency_arrow: {
+            style_key: :connector_line,
+            render: ->(m, anchor, base) { m.dependency_arrow_path(anchor, base) }
+          },
           package_anchor: {
             style_key: :connector_line,
             render: ->(m, anchor, base) { m.package_anchor_path(anchor, base) }
@@ -403,6 +414,28 @@ module Ea
           %(<path d="#{d}" shape-rendering="auto"/>)
         end
 
+        # Dependency arrowhead: same open-path form as arrow_path
+        # but EA's slimmer base-10 template. Coordinates are whole
+        # pixels in EA's output (e.g. "M 2732 183 L 2747 178
+        # L 2732 173").
+        def dependency_arrow_path(tip, base)
+          tx, ty = translate_point(tip)
+          bx, by = translate_point(base)
+          ux, uy = unit_vector(tx, ty, bx, by)
+          return nil unless ux
+
+          back_x = tx - ux * DEP_ARROW_HEIGHT
+          back_y = ty - uy * DEP_ARROW_HEIGHT
+          w1_x = back_x + (-uy) * DEP_ARROW_HALF_BASE
+          w1_y = back_y + ux * DEP_ARROW_HALF_BASE
+          w2_x = back_x - (-uy) * DEP_ARROW_HALF_BASE
+          w2_y = back_y - ux * DEP_ARROW_HALF_BASE
+          d = "M #{Canvas.coord(w1_x.round)} #{Canvas.coord(w1_y.round)} " \
+              "L #{Canvas.coord(tx.round)} #{Canvas.coord(ty.round)} " \
+              "L #{Canvas.coord(w2_x.round)} #{Canvas.coord(w2_y.round)}"
+          %(<path d="#{d}" shape-rendering="auto"/>)
+        end
+
         def unit_vector(tx, ty, bx, by)
           dx = tx - bx
           dy = ty - by
@@ -412,7 +445,7 @@ module Ea
           [dx / len, dy / len]
         end
         public :diamond_polygon, :triangle_polygon, :plus_path,
-               :arrow_path, :package_anchor_path
+               :arrow_path, :dependency_arrow_path, :package_anchor_path
 
         def translate_point(p)
           return p unless @canvas

data/lib/ea/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.29
+  version: 0.6.31
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -813,6 +813,7 @@ files:
 - lib/ea/sources/qea/annotation_builder.rb
 - lib/ea/sources/qea/classifier_builder.rb
 - lib/ea/sources/qea/connector_relationship_map.rb
+- lib/ea/sources/qea/context_diagram_support.rb
 - lib/ea/sources/qea/diagram_builder.rb
 - lib/ea/sources/qea/diagram_style_parser.rb
 - lib/ea/sources/qea/id_normalizer.rb