ea 0.6.4 → 0.6.6

data/lib/ea/svg/ea_emitter/element/header_line_provider/stereotype_label.rb

@@ -18,25 +18,26 @@ module Ea
               classifier = context.classifier
               return [] if classifier.is_a?(Ea::Model::InstanceSpecification)
 
-              label = label_for(classifier, context.umldi_keyword)
-              return [] unless label
+              labels = label_for(classifier, context.umldi_keyword)
+              return [] if labels.empty?
 
-              [[label, :normal]]
+              labels.map { |l| [l, :normal] }
             end
 
-            # @return [String, nil] «name» label or nil
+            # @return [Array<String>] «name» labels (EA renders one
+            # line per applied stereotype)
             def self.label_for(classifier, umldi_keyword)
-              return "«#{umldi_keyword}»" if umldi_keyword && !umldi_keyword.empty?
+              return ["«#{umldi_keyword}»"] if umldi_keyword && !umldi_keyword.empty?
 
               explicit = explicit_stereotype(classifier)
               return explicit if explicit
 
               case classifier
               when Ea::Model::Klass, Ea::Model::Package, Ea::Model::Note
-                nil
+                []
               else
                 fallback = fallback_name(classifier)
-                fallback ? "«#{fallback}»" : nil
+                fallback ? ["«#{fallback}»"] : []
               end
             end
 
@@ -47,7 +48,23 @@ module Ea
               refs = classifier.stereotype_refs
               return nil unless refs&.any?
 
-              "«#{refs.first}»"
+              refs.map { |ref| "«#{canonical(ref)}»" }
+            end
+
+            # EA displays canonical stereotype spellings regardless of
+            # how the QEA stored them (property → Property). Prefer the
+            # MDG alias registry when its definition is available; the
+            # overrides map covers the spellings verified directly
+            # against EA-published reference SVGs.
+            DISPLAY_OVERRIDES = {
+              "property" => "Property",
+              "featuretype" => "FeatureType",
+              "objecttype" => "ObjectType",
+              "codelist" => "CodeList"
+            }.freeze
+
+            def self.canonical(ref)
+              DISPLAY_OVERRIDES.fetch(ref.downcase, ref)
             end
 
             def self.fallback_name(classifier)

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

@@ -14,7 +14,7 @@ module Ea
           def self.render(lines, bounds:, first_y:, family:,
                           size:, size_unit: "pt",
                           fill: "#000000", weight_normal: 400, weight_bold: 700,
-                          stroke_in_text: "#000000", width_factor: 0.65,
+                          stroke_in_text: "#000000", width_factor: 0.612,
                           line_offset: 6)
             line_h = size + line_offset
             text_blocks = lines.each_with_index.map do |(text, style), idx|
@@ -23,11 +23,23 @@ module Ea
                        else weight_normal
                        end
               font_style = (style == :italic || style == :bold_italic) ? "italic" : "normal"
-              y = first_y + (idx * line_h)
-              centered_x = center_x_for(text, bounds, size, width_factor)
+              # EA spaces the line AFTER a right-aligned ghost 6px
+              # wider (ghost +13, next +32 at 7pt) - verified against
+              # EA-published reference SVGs.
+              y = first_y + (idx * line_h) +
+                  (idx >= 1 && lines.first.last == :italic ? 6 : 0)
+              x = if style == :italic
+                    # EA right-aligns the off-canvas parent ghost at
+                    # the box's right edge (verified across EA-published
+                    # reference SVGs).
+                    bounds.x + bounds.width -
+                      Ea::Svg::EaEmitter::TextRenderer.estimate_width(text, size, width_factor)
+                  else
+                    center_x_for(text, bounds, size, width_factor)
+                  end
               TextRenderer.new(
                 content: text,
-                x: centered_x, y: y,
+                x: x, y: y,
                 family: family, size: size, size_unit: size_unit,
                 weight: weight, style: font_style, fill: fill,
                 stroke_in_text: stroke_in_text, width_factor: width_factor

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

@@ -24,8 +24,8 @@ module Ea
         class LegendRenderer
           CONTAINER_RX = 3
           ICON_SIZE = 17
-          TITLE_Y_OFFSET = 19
-          FIRST_ITEM_Y_OFFSET = 30
+          TITLE_Y_OFFSET = 22
+          FIRST_ITEM_Y_OFFSET = 33
           ITEM_SPACING = 19
           ICON_X_OFFSET = 10
           ICON_LABEL_GAP = 22
@@ -130,11 +130,36 @@ module Ea
           end
 
           def title_text
-            x = bounds.x + (bounds.width / 2) - (title_text_width / 2)
+            x = title_x
             y = bounds.y + TITLE_Y_OFFSET
             build_text(legend.title, x: x, y: y, size: title_font_size, weight: 700)
           end
 
+          # EA centers the title over the ITEM BLOCK (icon left edge
+          # to the right end of the widest label), not the container
+          # box - verified against EA-published reference SVGs.
+          def title_x
+            icon_left = bounds.x + ICON_X_OFFSET
+            block_right = icon_left + ICON_LABEL_GAP +
+                          widest_item_label_width
+            block_left = icon_left
+            block_left + (block_right - block_left - title_text_width) / 2.0
+          end
+
+          CJK_RANGE = /[\u3000-\u9fff\uff00-\uffef]/
+
+          # CJK glyphs run ~0.82em, others ~0.612em (regressed from
+          # EA's own textLength values on mixed-script labels).
+          def estimated_width(text, size)
+            text.to_s.each_char.sum do |ch|
+              ch.match?(CJK_RANGE) ? size * 0.70 : size * 0.612
+            end
+          end
+
+          def widest_item_label_width
+            legend.items.map { |i| estimated_width(i.name, item_font_size) }.max || 0.0
+          end
+
           def item_top_y(index)
             bounds.y + FIRST_ITEM_Y_OFFSET + (index * ITEM_SPACING)
           end
@@ -148,7 +173,7 @@ module Ea
           end
 
           def title_text_width
-            legend.title.to_s.length * title_font_size * 0.6
+            estimated_width(legend.title, title_font_size)
           end
 
           def build_text(content, x:, y:, size:, weight:)

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

@@ -71,18 +71,29 @@ module Ea
                                                                 font_size: size,
                                                                 off_canvas_parent_name: parent_name) : []
           is_classifier = classifier.is_a?(Ea::Model::Classifier)
-          attr_lines = (is_classifier && show_attributes?) ? Element::AttributeRenderer.lines_for(classifier, lookup: attribute_lookup) : []
+          attr_lines = if is_classifier && show_attributes?
+                         Element::AttributeRenderer.lines_for(
+                           classifier, lookup: attribute_lookup,
+                           exclude_association_ids: drawn_association_ids
+                         )
+                       else
+                         []
+                       end
           op_lines = (is_classifier && show_operations?) ? Element::OperationRenderer.lines_for(classifier) : []
-          geometry = CompartmentGeometry.new(bounds: bounds, size: size,
-                                              header_lines_count: header_lines.size,
-                                              attr_lines_count: attr_lines.size,
-                                              op_lines_count: op_lines.size,
-                                              tagged_values_count: tagged_values_for(classifier).size,
-                                              header_top_padding: theme.compartments.header_top_padding,
-                                              header_line_offset: theme.compartments.header_line_offset,
-                                              divider_offset: theme.compartments.divider_offset,
-                                              attr_line_offset: theme.compartments.attr_line_offset,
-                                              attr_first_offset: theme.compartments.attr_first_offset)
+          geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
+                                           tagged_values_for(classifier).size,
+                                           header_lines)
+          # EA suppresses the whole attribute compartment when it does
+          # not fit the stored box height (never truncates rows) - the
+          # AOS box on CityFurniture hides its association property
+          # this way. Verified against EA-published reference SVGs.
+          if attr_lines.any? &&
+             geometry.attr_bottom_y.to_i + size > bounds.y + bounds.height
+            attr_lines = []
+            geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
+                                             tagged_values_for(classifier).size,
+                                             header_lines)
+          end
           RenderContext.new(
             element: element,
             bounds: bounds,
@@ -109,6 +120,47 @@ module Ea
           )
         end
 
+        def compartment_geometry(bounds, size, attr_lines, op_lines,
+                                 tagged_count, header_lines)
+          CompartmentGeometry.new(bounds: bounds, size: size,
+                                   header_lines_count: header_lines.size,
+                                   attr_lines_count: attr_lines.size,
+                                   op_lines_count: op_lines.size,
+                                   tagged_values_count: tagged_count,
+                                   header_top_padding: header_padding_for(header_lines),
+                                   header_line_offset: theme.compartments.header_line_offset,
+                                   divider_offset: theme.compartments.divider_offset,
+                                   attr_line_offset: theme.compartments.attr_line_offset,
+                                   attr_first_offset: attr_first_offset_for(attr_lines))
+        end
+
+        # EA seats a stereotype line 3px higher than a bare class name
+        # (first baseline +16 vs +19 at 7pt) - verified against the
+        # EA-published reference SVGs.
+        def header_padding_for(header_lines)
+          first = header_lines.first
+          return theme.compartments.header_top_padding unless first
+
+          if first.last == :italic
+            6 # ghost-led: EA seats the right-aligned ghost at +13
+          elsif first.first.to_s.start_with?("«")
+            9
+          else
+            theme.compartments.header_top_padding
+          end
+        end
+
+        # A stereotype group header («Property») sits 4px below where
+        # plain rows start (divider+18 vs divider+14 at 7pt).
+        def attr_first_offset_for(attr_lines)
+          attr_lines.first.to_s.start_with?("«") ? 11 : 7
+        end
+
+        def drawn_association_ids
+          (diagram.connectors || []).select(&:renderable?)
+                                    .map(&:relationship_ref).compact.to_set
+        end
+
         def enum_literals_for(classifier)
           return [] unless classifier.is_a?(Ea::Model::Enumeration)
 
@@ -166,19 +218,17 @@ module Ea
           (diagram.elements || []).any? { |e| e.model_element_ref == model_element_ref }
         end
 
-        # Returns true when any element placed on the current diagram
-        # lives in the same package as `parent`. EA suppresses the
-        # parent-class ghost line in that case — the parent's package
-        # is already "represented" on the diagram, so the off-canvas
-        # parent is implicitly visible to the reader.
+        # EA suppresses the parent-class ghost line only when the
+        # parent's package is itself placed on the diagram as a
+        # package element. A mere same-package classifier does NOT
+        # suppress it — verified against EA-published reference SVGs
+        # (CityFurniture renders the ghost for AbstractOccupiedSpace
+        # although the class shares its parent's package).
         def parent_package_represented_on_diagram?(parent)
           parent_pkg = parent.is_a?(Ea::Model::Classifier) ? parent.package_id : nil
           return false unless parent_pkg
 
-          (diagram.elements || []).any? do |e|
-            sibling = model_index[e.model_element_ref]
-            sibling.is_a?(Ea::Model::Classifier) && sibling.package_id == parent_pkg
-          end
+          (diagram.elements || []).any? { |e| e.model_element_ref == parent_pkg }
         end
 
         # EA renders a package's child classifiers and sub-packages as

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

@@ -17,12 +17,11 @@ module Ea
       # text-emitting layer.
       class FontResolver
         DEFAULT_FONT_FAMILY = "Yu Gothic UI"
-        # EA's default element compartment font size (matches
-        # reference SVGs which use 9pt for classifier header,
-        # attributes, operations, etc. — distinct from theme's
-        # diagram-level font size which applies only to frame
-        # label and swimlanes).
-        DEFAULT_ELEMENT_FONT_SIZE = 9
+        # EA's default element compartment font size. EA-published
+        # reference SVGs render body text at 7pt (the current EA
+        # theme size) for every element whose objectstyle fontsz is
+        # a use-default marker (see QEA DiagramBuilder.font_size_from).
+        DEFAULT_ELEMENT_FONT_SIZE = 7
 
         attr_reader :diagram, :theme
 

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

@@ -122,13 +122,23 @@ module Ea
             assoc = association_for(connector)
             return [nil, nil, nil] unless assoc
 
-            prop = property_at_end(assoc, end_kind)
+            prop = property_at_end(assoc, end_kind, connector)
             return [true, *property_role(prop)] if prop
 
             [false, *association_role(assoc, end_kind)]
           end
 
-          def property_at_end(association, end_kind)
+          def property_at_end(association, end_kind, connector = nil)
+            # EA renders the source classifier's synthesized
+            # association-end property (matched by the connector's
+            # relationship guid), falling back to the property index
+            # lookup by association source/target id.
+            if connector&.relationship_ref
+              placed = placed_classifier_id(association, end_kind)
+              prop = assoc_end_property(placed, connector.relationship_ref)
+              return prop if prop
+            end
+
             id = end_kind == :source ? association.source_id : association.target_id
             return nil unless id
 
@@ -137,9 +147,29 @@ module Ea
             fallback_property_lookup(id)
           end
 
+          def placed_classifier_id(association, end_kind)
+            end_kind == :source ? association.source_id : association.target_id
+          end
+
+          # Find the synthesized association-end property on the
+          # placed classifier whose association_id matches the
+          # connector's relationship reference.
+          def assoc_end_property(classifier_id, relationship_ref)
+            return nil unless classifier_id
+
+            classifier = model_index[classifier_id]
+            return nil unless classifier.is_a?(Ea::Model::Classifier)
+
+            (classifier.properties || []).find do |p|
+              p.association_id == relationship_ref
+            end
+          end
+
           # Linear-scan fallback for callers that did not wire in
           # the Document. Production paths go through Document's
           # property_index for O(1) lookup.
+
+
           def fallback_property_lookup(id)
             return nil unless model_index
 
@@ -155,11 +185,23 @@ module Ea
           def property_role(property)
             visibility = visibility_prefix(property)
             name = property.name.to_s
-            role = name.empty? ? nil : "#{visibility}#{name}"
+            type_name = property.type_name.to_s
+            line = if type_name.empty? || type_name == " "
+                     "#{visibility}#{name}"
+                   else
+                     "#{visibility}#{name}: #{namespace_double_colon(type_name)}"
+                   end
+            role = line.empty? ? nil : line
             mult = multiplicity_text(property)
             [role, mult]
           end
 
+          def namespace_double_colon(type_name)
+            return type_name if type_name.nil? || type_name.empty?
+
+            type_name.to_s.gsub(/([A-Za-z0-9_]):([A-Za-z])/, '\1::\2')
+          end
+
           def association_role(assoc, end_kind)
             name = end_kind == :source ? assoc.source_role_name : assoc.target_role_name
             lower = end_kind == :source ? assoc.source_multiplicity_lower : assoc.target_multiplicity_lower
@@ -202,7 +244,9 @@ module Ea
             offset_y = box["oy"] || box[:oy]
             return nil if offset_x.nil? && offset_y.nil?
 
-            [anchor[0] + offset_x.to_i, anchor[1] + offset_y.to_i]
+            # Waypoint anchors are mirrored to screen-down space; the
+            # stored OY offset counts the other way, so negate it.
+            [anchor[0] + offset_x.to_i, anchor[1] - offset_y.to_i]
           end
 
           def property_y_offset

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

@@ -73,16 +73,52 @@ module Ea
           target_pt = points.last
           boxes = connector.label_boxes || {}
 
+          src_tb, src_mb = end_boxes(boxes, :llt, :llb) ||
+                           default_label_boxes(points, :source)
+          tgt_tb, tgt_mb = end_boxes(boxes, :lrt, :lrb) ||
+                           default_label_boxes(points, :target)
+
           texts = []
-          end_renderer.texts(text_box: boxes[:llt], mult_box: boxes[:llb],
+          end_renderer.texts(text_box: src_tb, mult_box: src_mb,
                              anchor: source_pt, connector: connector,
                              end_kind: :source).each { |t| texts << t }
-          end_renderer.texts(text_box: boxes[:lrt], mult_box: boxes[:lrb],
+          end_renderer.texts(text_box: tgt_tb, mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
                              end_kind: :target).each { |t| texts << t }
           texts
         end
 
+        def end_boxes(boxes, text_key, mult_key)
+          return nil if boxes[text_key].nil? && boxes[mult_key].nil?
+
+          [boxes[text_key], boxes[mult_key]]
+        end
+
+        # EA's default label placement for connectors without stored
+        # label boxes: role name 5px along the line and 31px below it,
+        # multiplicity 18px along and 21px above (screen-down coords).
+        # Derived from 219 labels across EA-published reference SVGs.
+        def default_label_boxes(points, end_kind)
+          e = end_kind == :source ? points.first : points.last
+          other = end_kind == :source ? points[1] : points[-2]
+          return [nil, nil] unless e && other
+
+          ux = other[0] - e[0]
+          uy = other[1] - e[1]
+          len = Math.sqrt(ux**2 + uy**2)
+          return [nil, nil] if len < 0.5
+
+          ux /= len
+          uy /= len
+          vx = uy
+          vy = -ux
+          role_box = { "ox" => (5 * ux - 31 * vx).round,
+                       "oy" => (5 * uy - 31 * vy).round }
+          mult_box = { "ox" => (18 * ux + 21 * vx).round,
+                       "oy" => (18 * uy + 21 * vy).round }
+          [role_box, mult_box]
+        end
+
         def registry
           @registry ||= Label::Registry.new(model_index: model_index)
         end

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

@@ -20,7 +20,7 @@ module Ea
         DEFAULT_FILL = "#000000"
         DEFAULT_ROTATION = -0.00
         DEFAULT_STROKE_IN_TEXT = "#000000"
-        DEFAULT_WIDTH_FACTOR = 0.65
+        DEFAULT_WIDTH_FACTOR = 0.612
 
         attr_reader :content, :x, :y, :family, :size, :weight, :style,
                     :fill, :text_length, :rotation, :size_unit,
@@ -55,19 +55,108 @@ module Ea
 
         private
 
+        # nil coordinates occur on degenerate placements (e.g. label
+        # boxes without offsets); EA always has a position, so render
+        # at the origin rather than crashing the whole diagram.
         def format_attrs
-          %(x="#{format('%.2f', x)}" y="#{format('%.2f', y)}")
+          %(x="#{format('%.2f', x.to_f)}" y="#{format('%.2f', y.to_f)}")
         end
 
         def format_style
           "font-family:#{family}; font-weight:#{weight}; font-style:#{style}; font-size:#{size}#{size_unit}; fill:#{fill};fill-opacity:1.00; stroke:#{stroke_in_text}; stroke-opacity:0.00 stroke-width:0; white-space: pre;"
         end
 
-        def self.estimate_width(text, size, width_factor = 0.65)
-          content = text.to_s
-          space_count = content.count(" ")
-          letter_count = content.length - space_count
-          letter_count * size * width_factor + space_count * size * 0.3
+        # Per-codepoint advance widths (em), least-squares fitted from
+        # EA's own textLength attributes across ~8k published reference
+        # texts (mean residual 0.097em - real-metric extraction).
+        GLYPH_WIDTHS = {
+          "e" => 0.731,
+          "t" => 0.438,
+          "a" => 0.72,
+          "r" => 0.446,
+          "i" => 0.302,
+          "o" => 0.717,
+          "n" => 0.693,
+          " " => 0.311,
+          "s" => 0.568,
+          "c" => 0.567,
+          "l" => 0.287,
+          "u" => 0.732,
+          ":" => 0.433,
+          "m" => 1.125,
+          "+" => 0.951,
+          "d" => 0.707,
+          "p" => 0.703,
+          "C" => 0.725,
+          "g" => 0.726,
+          "y" => 0.733,
+          "." => 0.458,
+          "S" => 0.706,
+          "f" => 0.426,
+          "_" => 0.755,
+          "T" => 0.702,
+          "L" => 0.604,
+          "D" => 0.871,
+          "1" => 0.708,
+          "0" => 0.703,
+          "P" => 0.698,
+          "h" => 0.699,
+          "\u00bb" => 0.802,
+          "\u00ab" => 0.566,
+          "b" => 0.72,
+          "I" => 0.422,
+          "A" => 0.907,
+          "v" => 0.685,
+          "M" => 1.294,
+          "R" => 0.764,
+          ")" => 0.405,
+          "(" => 0.289,
+          "*" => 0.646,
+          "[" => -0.029,
+          "]" => 0.669,
+          "O" => 0.968,
+          "E" => 0.683,
+          "B" => 0.801,
+          "V" => 0.898,
+          "x" => 0.628,
+          "G" => 0.875,
+          "=" => 0.629,
+          "F" => 0.74,
+          "N" => 0.893,
+          "U" => 0.907,
+          "2" => 0.743,
+          "w" => 0.983,
+          "}" => 0.345,
+          "{" => 0.461,
+          "k" => 0.792,
+          "9" => 0.839,
+          "j" => 0.366,
+          "q" => 0.657,
+          "3" => 0.694,
+          "5" => 0.72,
+          ">" => 0.682,
+          "," => 0.549,
+          "-" => 0.485,
+          "<" => 0.696,
+          "Q" => 0.967,
+          "6" => 0.776,
+          "4" => 0.658,
+          "/" => 0.496,
+          "z" => 0.59,
+          "H" => 0.854,
+          "W" => 1.292,
+          "\"" => 0.508,
+          "J" => 0.555,
+          "X" => 0.711,
+          "7" => 0.671,
+          "8" => 0.74
+        }.freeze
+        GLYPH_FALLBACK = 0.61
+
+        def self.estimate_width(text, size, _width_factor = nil)
+          text.to_s.each_char.sum do |ch|
+            (GLYPH_WIDTHS[ch] || GLYPH_FALLBACK) * size.to_f
+          end
         end
 
         def formatted_text_length
@@ -77,7 +166,7 @@ module Ea
         end
 
         def formatted_transform
-          "rotate(#{format('%<r>.2f', r: rotation)} #{format('%.2f', x)} #{format('%.2f', y)})"
+          "rotate(#{format('%<r>.2f', r: rotation)} #{format('%.2f', x.to_f)} #{format('%.2f', y.to_f)})"
         end
 
         def escaped_content

data/lib/ea/svg/parity/checker.rb

@@ -25,6 +25,7 @@ module Ea
             text: count_diff("text"),
             group: top_level_group_diff,
             font_family: font_family_match,
+            font_size: font_size_match,
             view_box: view_box_match,
             text_overlap: text_overlap_ratio
           )
@@ -51,9 +52,23 @@ module Ea
         end
 
         def font_family_match
-          our_family = first_text_style(our_doc)[/font-family:([^;]+)/, 1]
-          ref_family = first_text_style(ref_doc)[/font-family:([^;]+)/, 1]
-          our_family == ref_family
+          font_style_histogram(our_doc, "font-family") ==
+            font_style_histogram(ref_doc, "font-family")
+        end
+
+        # Exact histogram of every emitted font-size (e.g.
+        # {"9.00"=>42, "13.00"=>21}) — a first-text comparison would
+        # pass diagrams whose body text renders at the wrong size.
+        def font_size_match
+          font_style_histogram(our_doc, "font-size") ==
+            font_style_histogram(ref_doc, "font-size")
+        end
+
+        def font_style_histogram(doc, property)
+          doc.css("text").each_with_object(Hash.new(0)) do |node, acc|
+            value = (node["style"] || "")[/#{Regexp.quote(property)}:([^;]+)/, 1]
+            acc[value] += 1 if value
+          end
         end
 
         def view_box_match
@@ -69,11 +84,6 @@ module Ea
           (our_set & ref_set).size.to_f / (our_set | ref_set).size.to_f
         end
 
-        def first_text_style(doc)
-          first = doc.css("text").first
-          first ? (first["style"] || "") : ""
-        end
-
         Diff = Struct.new(:ours, :reference, keyword_init: true) do
           def delta
             ours - reference
@@ -85,7 +95,7 @@ module Ea
         end
 
         Report = Struct.new(:rect, :path, :polygon, :text, :group,
-                            :font_family, :view_box, :text_overlap,
+                            :font_family, :font_size, :view_box, :text_overlap,
                             keyword_init: true) do
           def shape_delta_total
             [rect, path, polygon].sum(&:delta).abs