ea 0.6.3 → 0.6.5

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

@@ -202,7 +202,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

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ea
+  module Svg
+    module Parity
+      # Renders every diagram of a Document and diffs it against the
+      # EA-authored reference export for that diagram (EAID_-named
+      # files), aggregating itemized deltas into a corpus report.
+      #
+      # References stay wherever EA published them (e.g. an EA "Save
+      # as image" directory); nothing is copied into the gem.
+      class CorpusReport
+        DELTA_KEYS = %i[extra_text missing_text moved_text wrong_font
+                        wrong_size wrong_weight].freeze
+
+        attr_reader :document, :ref_dir
+
+        def initialize(document:, ref_dir:)
+          @document = document
+          @ref_dir = ref_dir
+        end
+
+        # Returns { diagrams: [...], totals: {...} } and writes JSON
+        # when output_path is given.
+        def run(output_path: nil)
+          index = document.index_by_id
+          rows = diagrams_with_references.map do |diagram|
+            measure_one(diagram, index)
+          end.compact
+
+          result = { totals: totals(rows), diagrams: rows }
+          File.write(output_path, JSON.pretty_generate(result)) if output_path
+          result
+        end
+
+        private
+
+        def diagrams_with_references
+          document.diagrams.select { |d| reference_path_for(d) }
+        end
+
+        # EA publishes images as EAID_<guid-with-underscores>.svg;
+        # fall back to the raw diagram id for non-QEA sources.
+        def reference_path_for(diagram)
+          [
+            File.join(ref_dir, "EAID_#{diagram.id.tr('-', '_')}.svg"),
+            File.join(ref_dir, "#{Ea::Sources::Qea::IdNormalizer.to_eaid(diagram.id)}.svg"),
+            File.join(ref_dir, "#{diagram.id}.svg")
+          ].find { |p| File.exist?(p) }
+        end
+
+        def measure_one(diagram, index)
+          ref_path = reference_path_for(diagram)
+          return nil unless ref_path
+
+          ours = Ea::Svg::EaEmitter::Document.new(
+            diagram, model_index: index, document: document
+          ).render
+          differ = Differ.new(ours: ours, reference: File.read(ref_path))
+          deltas = differ.text_deltas
+
+          {
+            id: diagram.id, name: diagram.name,
+            deltas: DELTA_KEYS.to_h { |k| [k, deltas[k].size] },
+            shapes: differ.shape_summary.slice(:matched, :missing, :extra)
+          }
+        end
+
+        def totals(rows)
+          sum = DELTA_KEYS.to_h { |k| [k, 0] }
+          shapes = { matched: 0, missing: 0, extra: 0 }
+          rows.each do |row|
+            DELTA_KEYS.each { |k| sum[k] += row[:deltas][k] }
+            shapes.each_key { |k| shapes[k] += row[:shapes][k] }
+          end
+          sum.merge(shapes: shapes, diagrams: rows.size)
+        end
+      end
+    end
+  end
+end