ea 0.6.140 → 0.6.142

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

@@ -197,9 +197,11 @@ module Ea
 
         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
-          end
+          # A DUID shared by several placements names none of them (QEA
+          # placement_order_reversed? needs a unique match too).
+          by_duid = placed_elements.select { |pe| pe.style.duid }.group_by { |pe| pe.style.duid }
+                                   .select { |_duid, placements| placements.one? }
+                                   .transform_values(&:first)
           by_subject = placed_elements.group_by { |pe| guid_key(pe.subject) }
 
           placed_connectors.each_with_index.map do |placed, index|
@@ -368,14 +370,28 @@ module Ea
         # The saved SOID/EOID can name the model connector's ends in reverse
         # order; the model connector decides which placement is the source.
         def placed_ends(style, by_duid, by_subject, edge_source, edge_target)
-          source = by_duid[style.soid] || sole_placement(by_subject, edge_source)
-          target = by_duid[style.eoid] || sole_placement(by_subject, edge_target)
+          named = [by_duid[style.soid], by_duid[style.eoid]]
+          source = named[0] || sole_placement(by_subject, edge_source)
+          target = named[1] || sole_placement(by_subject, edge_target)
+          if source.equal?(target) && named.one?
+            source, target = subject_placements(by_subject, named, edge_source, edge_target)
+          end
           return [source, target] unless source && target &&
                                          reversed_ends?(source, target, edge_source, edge_target)
 
           [target, source]
         end
 
+        # One stale DUID falls back to the relationship's own end, which can
+        # be the very placement the other DUID named; two distinct ends never
+        # share a box, so each end then takes its own subject's placement. A
+        # link whose SOID and EOID are one DUID is a genuine self link.
+        def subject_placements(by_subject, named, edge_source, edge_target)
+          [edge_source, edge_target].zip(named).map do |subject, placement|
+            sole_placement(by_subject, subject) || (placement if guid_key(placement&.subject) == guid_key(subject))
+          end
+        end
+
         def reversed_ends?(source, target, edge_source, edge_target)
           guid_key(edge_source) != guid_key(edge_target) &&
             guid_key(source.subject) == guid_key(edge_target) &&
@@ -399,12 +415,7 @@ module Ea
         end
 
         def connector_index
-          @connector_index ||= begin
-            conns = root.extension&.connectors&.connector || []
-            conns.each_with_object({}) do |c, acc|
-              acc[c.idref] = c if c.idref
-            end
-          end
+          @connector_index ||= ConnectorIndex.build(root)
         end
 
         def umldi_extractor

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

@@ -51,7 +51,7 @@ module Ea
             next nil unless pair.include?("=")
 
             key, value = pair.split("=", 2)
-            [key, value] if key && value && !value.empty?
+            [key.strip, value] if key && value && !value.empty?
           end.to_h
         end
 

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

@@ -26,6 +26,7 @@ module Ea
 
         def initialize(document)
           @attributes = index(document, "attribute", "properties")
+          @attribute_stereotypes = index(document, "attribute", "stereotype", "stereotype")
           @returns = index(document, "operation", "type")
           @parameters = index(document, "parameter", "properties")
         end
@@ -34,6 +35,12 @@ module Ea
           @attributes[id]
         end
 
+        # Stereotype EA stores on the attribute row
+        # (<attribute><stereotype stereotype="voidable"/>).
+        def attribute_stereotype(id)
+          @attribute_stereotypes[id]
+        end
+
         def return_type(operation_id)
           @returns[operation_id]
         end
@@ -44,11 +51,11 @@ module Ea
 
         private
 
-        def index(document, owner, child)
+        def index(document, owner, child, attribute = "type")
           return {} unless document
 
           document.xpath(%(//*[local-name()="#{owner}"][@*[local-name()="idref"]])).each_with_object({}) do |node, acc|
-            type = node.at_xpath(%(*[local-name()="#{child}"]/@type))&.value
+            type = node.at_xpath(%(*[local-name()="#{child}"]/@#{attribute}))&.value
             idref = node.at_xpath("@*[local-name()='idref']").value
             acc[idref] = type unless type.nil? || type.empty?
           end

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

@@ -51,12 +51,21 @@ module Ea
           end
         end
 
+        # Extension connector type => handler; a nil-returning handler skips
+        # the connector (Dependency counts only when stereotyped import).
+        EXTENSION_IMPORTS = {
+          "Package" => :package_import_relationship,
+          "Nesting" => :package_import_relationship,
+          "Dependency" => :stereotyped_dependency_import
+        }.freeze
+
         def extension_import_relationship(id, connector)
-          case connector.properties&.ea_type
-          when "Package" then package_import_relationship(id, connector)
-          when "Dependency"
-            dependency_import_relationship(id, connector) if connector_stereotype(connector) == "import"
-          end
+          handler = EXTENSION_IMPORTS[connector.properties&.ea_type]
+          handler && method(handler).call(id, connector)
+        end
+
+        def stereotyped_dependency_import(id, connector)
+          dependency_import_relationship(id, connector) if connector_stereotype(connector) == "import"
         end
 
         # EA exports elementImport outside packagedElement, so the model walk
@@ -73,6 +82,8 @@ module Ea
           connector&.xrefs&.value.to_s[CONNECTOR_STEREOTYPE]
         end
 
+        # Nesting connectors, like package imports, exist only in the
+        # extension; QEA models both as an Association between the ends.
         def package_import_relationship(id, connector)
           Ea::Model::Association.new(
             id: id,
@@ -245,12 +256,7 @@ module Ea
         end
 
         def connector_index
-          @connector_index ||= begin
-            connectors = root.extension&.connectors&.connector || []
-            connectors.each_with_object({}) do |connector, index|
-              index[connector.idref] = connector if connector.idref
-            end
-          end
+          @connector_index ||= ConnectorIndex.build(root)
         end
 
         def navigable?(id, endpoint)

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

@@ -18,21 +18,17 @@ module Ea
             return {} unless reversed_tree_candidate?(model, link, bounds, offsets)
 
             start, finish = bounds.values_at(:source, :target)
-            bus, start_edge, finish_edge = reversed_tree_levels(start, finish)
-            return {} unless bus
+            route = reversed_tree_points(start, finish, ray_geometry(offsets, edge), stored_bus_levels(link))
+            return {} unless route
 
-            geom = ray_geometry(offsets, edge)
-            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
-            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
-
-            reversed_tree_fields(model, first, last, bus, first[1] != start_edge)
+            reversed_tree_fields(model, route[0], route[1])
           end
 
-          def reversed_tree_fields(model, first, last, bus, beside)
+          def reversed_tree_fields(model, points, beside)
             style = model.style.to_h.except(:umldi_route, :reversed_ends)
             style[:left_seated_source] = true if beside
-            ends = [point_for(first), point_for(last)]
-            { waypoints: points_to_waypoints([first, [first[0], bus], [last[0], bus], last]),
+            ends = [point_for(points.first), point_for(points.last)]
+            { waypoints: points_to_waypoints(points),
               source_anchor: ends[0], target_anchor: ends[1], source_port: ends[0], target_port: ends[1],
               style: style }
           end
@@ -49,26 +45,14 @@ module Ea
           def reversed_corner_metadata(model, link, bounds, offsets, edge)
             return {} unless reversed_corner_candidate?(model, link, bounds, offsets, edge)
 
-            boxes = bounds.values_at(:source, :target)
-            origins = corner_origins(boxes, ray_geometry(offsets, edge))
-            bend = Ea::Model::Point.new(**%i[x y].zip(intermediate_waypoints(link).first).to_h)
-            ends = origins.zip(boxes).map { |origin, box| corner_exit(origin, bend, box) }
-            ends.all? ? corner_fields(origins, bend, ends) : {}
-          end
+            origins, points = reversed_corner_points(bounds.values_at(:source, :target), ray_geometry(offsets, edge),
+                                                     intermediate_waypoints(link).first)
+            return {} unless points
 
-          def corner_fields(origins, bend, ends)
-            { waypoints: points_to_waypoints([ends[0], bend, ends[1]].map { |point| [point.x, point.y] }),
+            { waypoints: points_to_waypoints(points.map { |point| [point.x, point.y] }),
               source_anchor: origins[0], target_anchor: origins[1] }
           end
 
-          def corner_origins(boxes, geom)
-            [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]), stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
-          end
-
-          def corner_exit(origin, bend, box)
-            inside_box?(origin, box) ? diagonal_corner_exit(origin, bend, box) : origin
-          end
-
           def reversed_corner_candidate?(model, link, bounds, offsets, edge)
             model.connector_type == "Association" && model.style[:reversed_ends] && edge == 2 &&
               model.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] &&

data/lib/ea/sources/xmi.rb

@@ -25,11 +25,13 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :TagBuilder, "ea/sources/xmi/tag_builder"
+      autoload :ConstraintBuilder, "ea/sources/xmi/constraint_builder"
       autoload :LegendBuilder, "ea/sources/xmi/legend_builder"
       autoload :NoteBuilder, "ea/sources/xmi/note_builder"
       autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
       autoload :StoredRoute, "ea/sources/xmi/stored_route"
+      autoload :ConnectorIndex, "ea/sources/xmi/connector_index"
       autoload :ExtensionTypes, "ea/sources/xmi/extension_types"
       autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
       autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"

data/lib/ea/spa/generator.rb

@@ -17,7 +17,8 @@ module Ea
       attr_reader :document, :mode, :output_path, :shard_url_for, :configuration
 
       def initialize(document, output:, mode: nil, shard_url_for: nil,
-                     configuration: nil)
+                     configuration: nil, frame: false)
+        @frame = frame
         @document = document
         @output_path = output
         @mode = (mode || DEFAULT_MODE).to_sym
@@ -32,7 +33,8 @@ module Ea
       def projector
         @projector ||= Projector.new(document,
                                       shard_url_for: shard_url_for,
-                                      configuration: configuration)
+                                      configuration: configuration,
+                                      frame: @frame)
       end
 
       def strategy_class

data/lib/ea/spa/projector.rb

@@ -15,8 +15,9 @@ module Ea
     class Projector
       attr_reader :document, :shard_url_for, :configuration
 
-      def initialize(document, shard_url_for: nil, configuration: nil)
+      def initialize(document, shard_url_for: nil, configuration: nil, frame: false)
         @document = document
+        @frame = frame
         @shard_url_for = shard_url_for || default_shard_url
         @configuration = configuration
       end
@@ -288,7 +289,8 @@ module Ea
         payload["svg"] = Ea::Svg::EaEmitter::Document.new(
           diagram,
           model_index: document.index_by_id,
-          document: document
+          document: document,
+          frame: @frame
         ).render
         payload
       rescue StandardError => e

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

@@ -12,7 +12,7 @@ module Ea
       # the 7pt default): 31 for fontsz 100, 30 for 90, 28 for the
       # default. A plain Note, and a Package that draws no "(from
       # Parent)" subtitle, keep the bare 10 margin, as does a classifier
-      # of the diagram's own package. Misses: 2 outliers.
+      # or instance of the diagram's own package. Misses: 2 outliers.
       class BottomMargin
         BARE = 10
         LINE_ALLOWANCE = 21
@@ -41,7 +41,7 @@ module Ea
           model = model_index && model_index[element.model_element_ref]
           return home_text_margin(element) if home_text?(model, diagram)
           return BARE if plain_note?(model) || bare_package?(model, diagram) ||
-                         home_classifier?(model, diagram)
+                         home_element?(model, diagram)
 
           LINE_ALLOWANCE + points(element)
         end
@@ -60,17 +60,21 @@ module Ea
           model.is_a?(Ea::Model::Note) && model.note_type != "Text"
         end
 
-        # A classifier that lives in the diagram's own package draws no
-        # "(from Package)" row under its name (nor an owner-class
-        # qualifier), so EA keeps only the bare margin below it. Checked
-        # on the 7 PLATEAU diagrams whose lowest class is in the
-        # diagram's package (all natively 10) against the 84 that are
-        # foreign (all 28..31).
-        def self.home_classifier?(model, diagram)
-          model.is_a?(Ea::Model::Classifier) &&
+        # An element of the diagram's own package (a classifier, nested
+        # in an owner class or not, or an instance) draws no "(from
+        # Package)" row under its name, so EA keeps only the bare margin
+        # below it. EMPIRICAL FIT, checked on: the 7 PLATEAU diagrams
+        # whose lowest class is in the diagram's package (all natively
+        # 10) against the 84 foreign ones (all 28..31); basic.qea
+        # 3B8BD087 and D14AA320 (lowest an own-package "Object B"
+        # instance) and 372F7F7B, 4FC1D352, 6D0349D5 (lowest a Klass
+        # nested in "Class A.x" / "Class B" of the own package), all
+        # natively 10; and the foreign basic instances, natively 28.
+        def self.home_element?(model, diagram)
+          (model.is_a?(Ea::Model::Classifier) ||
+            model.is_a?(Ea::Model::InstanceSpecification)) &&
             !diagram.package_id.to_s.empty? &&
-            model.package_id == diagram.package_id &&
-            model.nested_parent_name.to_s.empty?
+            model.package_id == diagram.package_id
         end
 
         # A Text element of the diagram's own package keeps 13 + its

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

@@ -33,6 +33,13 @@ module Ea
 
         attr_reader :diagram, :model_index
 
+        # Where the leftmost model x lands: 30 + min_x capped at 35. A
+        # negative min_x keeps the 30 of min_x 0 (the corpus has none),
+        # so content left of the origin is not drawn off the canvas.
+        def self.inset_left_for(min_x)
+          [[INSET_LEFT - 5 + min_x, INSET_LEFT - 5].max, INSET_LEFT].min
+        end
+
         def initialize(diagram, model_index: nil)
           @diagram = diagram
           @model_index = model_index
@@ -53,7 +60,7 @@ module Ea
           # Left inset scales from 30 up to the 35 cap with the
           # stored leftmost x: leftmost drawn x = 30 + min_x capped
           # at 35 (corpus: min_x 0 -> 30, 2 -> 32, 4 -> 34, >=5 -> 35).
-          @effective_inset_left = [INSET_LEFT - 5 + min_x, INSET_LEFT].min
+          @effective_inset_left = self.class.inset_left_for(min_x)
           [
             min_x,
             min_y,
@@ -62,19 +69,7 @@ module Ea
           ]
         end
 
-        private
-
-        # Element x-extent: logical bounds only (matches EA's canvas
-        # left/right exactly).
-        # Element y-extent: union of logical + image_bounds (image
-        # extends below bounds for shadow / image padding), plus the
-        # "(from Parent)" subtitle extent: EA draws the subtitle 15px
-        # below the body and its text descent adds ~4 more, reserving
-        # 19px of canvas below subtitle-bearing packages (the +19
-        # height family: 05DF5000 Main, Metadata All, package
-        # Clients/Suppliers contexts).
-        SUBTITLE_CANVAS_EXTRA = 19
-
+        # Canvas points reserved below "(from Parent)" subtitles.
         def subtitle_points
           pts = []
           (diagram.elements || []).each do |e|
@@ -88,6 +83,19 @@ module Ea
           pts
         end
 
+        private
+
+        # Element x-extent: logical bounds only (matches EA's canvas
+        # left/right exactly).
+        # Element y-extent: union of logical + image_bounds (image
+        # extends below bounds for shadow / image padding), plus the
+        # "(from Parent)" subtitle extent: EA draws the subtitle 15px
+        # below the body and its text descent adds ~4 more, reserving
+        # 19px of canvas below subtitle-bearing packages (the +19
+        # height family: 05DF5000 Main, Metadata All, package
+        # Clients/Suppliers contexts).
+        SUBTITLE_CANVAS_EXTRA = 19
+
         def element_points
           pts = []
           (diagram.elements || []).each do |e|

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

@@ -23,6 +23,8 @@ module Ea
         FRAME_INSET_LEFT = 35
         INSET_TOUCHING_ORIGIN = 30
         FRAME_INSET_TOP = 40
+        # Where the diagram frame's border line sits from the canvas edge.
+        FRAME_BORDER_INSET = 6
 
         attr_reader :min_x, :min_y, :width, :height, :inset_left, :inset_top
 
@@ -32,8 +34,8 @@ module Ea
                        insets: [FRAME_INSET_LEFT, FRAME_INSET_TOP])
           @min_x = min_x
           @min_y = min_y
-          @width = width
-          @height = height
+          @width = whole(width)
+          @height = whole(height)
           @inset_left, @inset_top = insets
         end
 
@@ -60,11 +62,23 @@ module Ea
                                        bottom: BottomMargin.for(diagram, model_index))
           end
 
+          return empty_framed(diagram, min_x, min_y) unless bc.max_x
+
           new(min_x: min_x, min_y: min_y, width: width, height: height,
               insets: [bc.effective_inset_left || FRAME_INSET_LEFT,
                        FRAME_INSET_TOP])
         end
 
+        # No element to size on: the frame alone, wide enough for its
+        # name tab.
+        def self.empty_framed(diagram, min_x, min_y)
+          width = [INSET_TOUCHING_ORIGIN + BoundsCalculator::INSET_RIGHT,
+                   DiagramFrame.new(canvas: nil).min_width(diagram)].max
+          new(min_x: min_x, min_y: min_y, width: width,
+              height: BoundsCalculator::INSET_TOP + BoundsCalculator::INSET_BOTTOM,
+              insets: [BoundsCalculator.inset_left_for(min_x), FRAME_INSET_TOP])
+        end
+
         # Second-pass canvas over the DRAWN extents captured by the
         # element pass (grown classifiers, autosized packages, plus
         # BoundsCalculator's subtitle reservation). EA sizes the
@@ -79,7 +93,7 @@ module Ea
             pts << [b.x, b.y]
             pts << [b.x + b.width, b.y + b.height]
           end
-          extra = base.send(:subtitle_points)
+          extra = base.subtitle_points
           min_x = (pts + extra).map(&:first).min || 0
           min_y = (pts + extra).map(&:last).min || 0
           max_x = (pts + extra).map(&:first).max || 0
@@ -95,8 +109,7 @@ module Ea
 
           # Same scaled rule as BoundsCalculator: drawn leftmost =
           # min(35, 30 + min_x).
-          inset_left = [BoundsCalculator::INSET_LEFT - 5 + min_x,
-                        BoundsCalculator::INSET_LEFT].min
+          inset_left = BoundsCalculator.inset_left_for(min_x)
           new(min_x: min_x, min_y: min_y,
               width: (max_x - min_x) + inset_left +
                      BoundsCalculator::INSET_RIGHT,
@@ -105,6 +118,25 @@ module Ea
               insets: [inset_left, FRAME_INSET_TOP])
         end
 
+        # This canvas when every point of `shapes` ([min_x, min_y, max_x,
+        # max_y] in canvas coordinates) lies inside its frame border (the
+        # FRAME_BORDER_INSET line), otherwise a canvas grown so the shapes
+        # sit CONTENT_MARGIN inside the border on the overflowing sides.
+        def holding(shapes)
+          left, top, right, bottom = shapes
+          reach = CanvasAnchor::CONTENT_MARGIN
+          grow_left = left < FRAME_BORDER_INSET ? reach - left : 0
+          grow_top = top < FRAME_BORDER_INSET ? reach - top : 0
+          new_width = right > width - FRAME_BORDER_INSET ? right + reach : width
+          new_height = bottom > height - FRAME_BORDER_INSET ? bottom + reach : height
+          return self if [grow_left, grow_top].all?(&:zero?) &&
+                         new_width == width && new_height == height
+
+          Canvas.new(min_x: min_x - grow_left, min_y: min_y - grow_top,
+                     width: new_width + grow_left, height: new_height + grow_top,
+                     insets: [inset_left, inset_top])
+        end
+
         def view_box
           "0 0 #{width} #{height}"
         end
@@ -139,6 +171,12 @@ module Ea
 
         private
 
+        # Measured extents arrive as Floats ("508.0"); EA writes whole
+        # pixels into the viewBox and background rect.
+        def whole(pixels)
+          pixels.is_a?(Float) && pixels == pixels.to_i ? pixels.to_i : pixels
+        end
+
         def format_cm(px)
           return "0cm" if px.nil? || px.zero?
 

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

@@ -25,6 +25,12 @@ module Ea
       # 4881CEEE, 70C77F92, 846DD800, 88AF6BD7, AC2191E3). Below, the
       # same box (its top is the first baseline less the font height,
       # its height the stored CY) + 5 holds the canvas open on 95246DCF.
+      #
+      # Drawn text also holds the right and bottom edges open (text
+      # right/bottom + TEXT_MARGIN, symmetric with the origin rule), so
+      # a name wider than its box is not clipped. Checked on the 188
+      # PLATEAU natives: widths/heights unchanged (185/188, 188/188);
+      # 8DAB169F moves 13 closer; no native contradicts it.
       module CanvasAnchor
         CONTENT_MARGIN = 10
         TEXT_MARGIN = 5
@@ -66,18 +72,20 @@ module Ea
           origin_x = origin(shapes && shapes[0], texts && texts[0])
           origin_y = origin(shapes && shapes[1], texts && texts[1])
           Canvas.new(min_x: origin_x, min_y: origin_y,
-                     width: right_edge(shapes, label_reach) - origin_x,
-                     height: bottom_edge(shapes, label_reach, bottom) - origin_y,
+                     width: right_edge(shapes, texts, label_reach) - origin_x,
+                     height: bottom_edge(shapes, texts, label_reach, bottom) - origin_y,
                      insets: [0, 0])
         end
 
-        def right_edge(shapes, label_reach)
+        def right_edge(shapes, texts, label_reach)
           [shapes && shapes[2] + CONTENT_MARGIN,
+           texts && (texts[2] + TEXT_MARGIN).ceil,
            label_reach && label_reach[0] + LABEL_BOX_MARGIN].compact.max
         end
 
-        def bottom_edge(shapes, label_reach, bottom)
+        def bottom_edge(shapes, texts, label_reach, bottom)
           [shapes[3] + bottom,
+           texts && (texts[3] + TEXT_MARGIN).ceil,
            label_reach && label_reach[1] + LABEL_BOX_MARGIN].compact.max
         end
 

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

@@ -6,6 +6,11 @@ module Ea
       module Compartment
         # Attribute compartment. Skipped when no attribute lines.
         module Attributes
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -11,6 +11,11 @@ module Ea
         # content and suppresses them when they would overflow the
         # stored box height (never truncates rows).
         module Constraints
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)

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

@@ -8,6 +8,11 @@ module Ea
         # italic header + each literal name. Skipped when the
         # classifier has no literals or no content geometry.
         module EnumLiterals
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           # Caption and literal rows share the same baseline spacing.

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

@@ -7,6 +7,11 @@ module Ea
         # Header compartment: stereotype label + class name. Skips
         # rendering when the classifier produces no header lines.
         module Header
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)
@@ -29,10 +34,12 @@ module Ea
             )
           end
 
+          # No element font size of its own: QEA marks it inherited, XMI
+          # records the missing size without the flag.
           def default_signal_header?(context)
             context.classifier.is_a?(Ea::Model::Signal) &&
               context.classifier.stereotype_refs.empty? &&
-              context.element.font_size_inherited == true &&
+              context.element.font_size.nil? &&
               context.element.font_family.nil? &&
               !context.element.font_bold && !context.element.font_italic
           end

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

@@ -8,6 +8,11 @@ module Ea
         # compartment (attributes / operations / literals / tagged
         # values). Skipped when there is no content below.
         module HeaderDivider
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)
@@ -40,7 +45,7 @@ module Ea
           end
 
           def object_diagram?(context)
-            context.diagram && context.diagram.diagram_type == "Object"
+            context.diagram&.object_diagram?
           end
 
           def hand_draw?(context)

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

@@ -12,6 +12,11 @@ module Ea
         # InstanceSpecification or has neither slots nor a
         # classifier.
         module InstanceSlots
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           ROW_OFFSET = 13
           SUBTITLE_OFFSET_FROM_BOTTOM = 15
 

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

@@ -8,6 +8,11 @@ module Ea
         # short horizontal line below each instance name to denote
         # that it is an instance (UML convention).
         module InstanceUnderline
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::SQUARE_MITER
+          end
+
           Y_OFFSET = 1
 
           module_function
@@ -36,7 +41,7 @@ module Ea
           end
 
           def object_diagram?(context)
-            context.diagram && context.diagram.diagram_type == "Object"
+            context.diagram&.object_diagram?
           end
           module_function :object_diagram?
 

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

@@ -10,6 +10,11 @@ module Ea
         # Real OCL constraints render trailing, after the content —
         # the two are distinct compartments.
         module Marker
+          # The pen the first group of this compartment leaves behind.
+          def self.pen(_context)
+            Pen::ROUND_BEVEL
+          end
+
           module_function
 
           def render(context)