ea 0.6.18 → 0.6.20

data/lib/ea/fonts/metrics.rb

@@ -4,12 +4,14 @@ require "json"
 
 module Ea
   module Fonts
-    # Advance-width metrics for Carlito, metric-compatible with
-    # Calibri. EA's exported textLength values encode Carlito
-    # advances scaled by per-style factors, so text widths computed
-    # here match EA's published SVGs to sub-pixel precision — far
-    # tighter than the legacy fitted-codepoint table, and style-aware
-    # (bold/italic variants), which the legacy table lacked.
+    # Advance-width metrics for the fonts EA's published SVGs use:
+    # Carlito (metric-compatible with Calibri), Arial, and Arial
+    # Narrow. EA's exported textLength values encode per-family,
+    # per-style, per-POINT-SIZE scale factors applied to the font's
+    # design advances (fitted by exact-count maximization against
+    # EA-published SVGs), so text widths computed here match EA's
+    # output to sub-pixel precision — far tighter than any legacy
+    # fitted-codepoint table, and style/size aware.
     module Metrics
       DATA_PATH = File.expand_path("carlito_metrics.json", __dir__)
 
@@ -21,16 +23,23 @@ module Ea
         [true, true] => :bold_italic
       }.freeze
 
-      # Families whose glyph metrics match the Carlito tables.
-      SUPPORTED_FAMILIES = %w[Carlito Calibri].freeze
+      # Families metric-compatible with a data-file family (the key
+      # is rendered even when the QEA named the other one).
+      FAMILY_ALIASES = {
+        "calibri" => "Carlito",
+        "carlito" => "Carlito",
+        "arial" => "Arial",
+        "arial narrow" => "Arial Narrow"
+      }.freeze
 
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
 
-      # Carlito has no CJK glyphs; EA's renderer falls back to a
-      # proportional CJK font whose advances measure ~0.709em at the
-      # NOMINAL size (not scaled by the per-style factors) — fitted
-      # from EA-published textLengths (52 mixed-script samples).
+      # Carlito/Arial have no CJK glyphs; EA's renderer falls back to
+      # a proportional CJK font whose advances measure ~0.709em at
+      # the NOMINAL size (not scaled by the per-style factors) —
+      # fitted from EA-published textLengths (52 mixed-script
+      # samples).
       CJK_ADVANCE = 0.709
       CJK_RANGES = [
         (0x3000..0x303F),   # CJK punctuation
@@ -48,18 +57,23 @@ module Ea
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
-        latin, cjk_count = split_advance(text, weight: weight, style: style)
-        (latin * size_pt.to_f * factor_for(weight, style) +
+        latin, cjk_count = split_advance(text, family: family,
+                                                weight: weight, style: style)
+        (latin * size_pt.to_f * factor_for(family, size_pt, weight, style) +
          cjk_count * CJK_ADVANCE * size_pt.to_f).round(3)
       end
 
       def supported_family?(family)
-        SUPPORTED_FAMILIES.include?(family.to_s)
+        !resolve_family(family).nil?
+      end
+
+      def resolve_family(family)
+        FAMILY_ALIASES[family.to_s.downcase]
       end
 
       # Returns [latin_em (factor-scaled later), cjk_glyph_count].
-      def split_advance(text, weight: nil, style: nil)
-        table = table_for(weight, style)
+      def split_advance(text, family: nil, weight: nil, style: nil)
+        table = table_for(family, weight, style)
         latin = 0.0
         cjk = 0
         text.each_char.each do |ch|
@@ -76,12 +90,20 @@ module Ea
         CJK_RANGES.any? { |range| range.cover?(cp) }
       end
 
-      def factor_for(weight, style)
-        data["factors"][STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s]
+      # EA's scale factor varies by point size (GDI quantization):
+      # Carlito regular fits 1.390 at 7pt but 1.432 at 9pt. Sizes
+      # without a fitted entry use the style's default (7pt, the
+      # corpus's dominant size).
+      def factor_for(family, size_pt, weight, style)
+        style = STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s
+        table = data["factors"].fetch(resolve_family(family), {})
+                                  .fetch(style, {})
+        table[size_pt.to_i.to_s] || table["default"] || 1.0
       end
 
-      def table_for(weight, style)
-        data["advance"][STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s]
+      def table_for(family, weight, style)
+        style = STYLE_KEYS.fetch([bold?(weight), italic?(style)], :regular).to_s
+        data["advance"].fetch(resolve_family(family), {}).fetch(style, {})
       end
 
       def data
@@ -100,28 +122,46 @@ module Ea
         format("U+%04X", ch.ord)
       end
 
-      # Resolves the four Carlito style TTFs through the fontist gem
-      # (system index + downloaded formulas). Empty when fontist is
-      # unavailable or Carlito is not installed.
-      def carlito_font_files
+      # Resolves a family's four style TTFs through the fontist gem
+      # (system index + downloaded formulas). Style variants are
+      # identified from each file's head.macStyle bits — filenames
+      # vary across fontist formulas and system copies ("ArialBd",
+      # "Arial Narrow Bold"), so name-matching is unreliable. The
+      # first file matching each style wins (fontist orders the
+      # downloaded formulas ahead of system copies). Empty when
+      # fontist is unavailable or the family is not installed.
+      def font_files_for(family)
         require "fontist"
-        styles = %w[Regular Bold Italic BoldItalic]
-        Fontist::SystemFont.find("Carlito").filter_map do |path|
+        Fontist::SystemFont.find(family).each_with_object({}) do |path, out|
           next unless path.downcase.end_with?(".ttf")
 
-          style = File.basename(path, ".ttf").delete_prefix("Carlito-")
-          match = styles.find { |s| s.casecmp?(style) }
-          next unless match
+          style = style_from_mac_style(path)
+          next unless style
 
-          [match, path]
-        end.to_h
+          out[style] ||= path
+        end
       rescue LoadError, StandardError => e
-        raise if ENV['EA_FONTS_DEBUG']
+        raise if ENV["EA_FONTS_DEBUG"]
 
         {}
       end
 
-      # Reads advance widths from a TTF via the fontian gem (used by
+      # head.macStyle: bit 0 = BOLD, bit 1 = ITALIC.
+      def style_from_mac_style(path)
+        require "fontisan"
+        font = Fontisan::FontLoader.load(path)
+        mac_style = font.table("head").mac_style
+        key = [mac_style & 1 == 1, mac_style & 2 == 2]
+        STYLE_KEYS[key]
+      end
+
+      # Carlito's data-file name (historical) differs from the
+      # fontist family name used to resolve its TTFs.
+      def carlito_font_files
+        font_files_for("Carlito")
+      end
+
+      # Reads advance widths from a TTF via the fontisan gem (used by
       # `rake fonts:validate` to re-derive the tables).
       def advances_from_font(path)
         require "fontisan"

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

@@ -4,9 +4,12 @@ module Ea
   module Svg
     module EaEmitter
       module Compartment
-        # Constraints compartment. Skipped when the classifier has no
-        # constraints. Renders an italic "constraints" header and one
-        # "{name}" line per constraint.
+        # Real (OCL) constraints compartment. Skipped when the
+        # classifier has no constraints — the {root}/{leaf} marker
+        # renders in its own Marker compartment between the divider
+        # and the attributes. EA seats OCL constraint lines after the
+        # content and suppresses them when they would overflow the
+        # stored box height (never truncates rows).
         module Constraints
           DEFAULT_TEXT_COLOR = "#000000"
 
@@ -16,10 +19,15 @@ module Ea
             return nil unless context.constraints&.any?
             return nil unless context.geometry.tagged_value_first_y
 
+            first_y = context.geometry.tagged_value_first_y
+            line_h = context.size + 6
+            last_y = first_y + (context.constraints.size - 1) * line_h
+            return nil if last_y + 4 > context.bounds.y + context.bounds.height
+
             Element::ConstraintRenderer.render(
               context.constraints,
               bounds: context.bounds,
-              first_y: context.geometry.tagged_value_first_y,
+              first_y: first_y,
               family: context.family, size: context.size,
               fill: DEFAULT_TEXT_COLOR
             )

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # {root}/{leaf} marker compartment. EA seats the marker line
+        # DIRECTLY BELOW the header divider, BEFORE the attribute
+        # rows (each marker row shifts the attributes down one row).
+        # Real OCL constraints render trailing, after the content —
+        # the two are distinct compartments.
+        module Marker
+          module_function
+
+          def render(context)
+            return nil unless context.marker_lines&.any?
+            return nil unless context.geometry.marker_first_y
+
+            Element::ConstraintRenderer.render(
+              context.marker_lines,
+              bounds: context.bounds,
+              first_y: context.geometry.marker_first_y,
+              family: context.family, size: context.size
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,8 +13,6 @@ module Ea
         # (379 diagrams, 378 exact): classifiers never render the
         # subtitle, and ShowForeign=0 diagrams render none.
         module PackageFromParent
-          Y_OFFSET_FROM_BOTTOM = 5
-
           module_function
 
           def render(context)
@@ -39,10 +37,14 @@ module Ea
 
           module_function :render
 
+          # EA draws the subtitle 15px BELOW the body bottom (outside
+          # the box) — verified against EA-published package SVGs.
+          Y_OFFSET_FROM_BOTTOM = 15
+
           def subtitle(text, context)
             bounds = context.bounds
             fill = context.theme.attribute_text_color
-            y = bounds.y + bounds.height - Y_OFFSET_FROM_BOTTOM
+            y = bounds.y + bounds.height + Y_OFFSET_FROM_BOTTOM
             # EA centers the subtitle by its integer textLength inside
             # the package BODY and floors x.
             body_width = Element::PackageShapeRenderer.body_width_for(

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

@@ -20,6 +20,7 @@ module Ea
         autoload :EnumLiterals, "ea/svg/ea_emitter/compartment/enum_literals"
         autoload :TaggedValues, "ea/svg/ea_emitter/compartment/tagged_values"
         autoload :Constraints, "ea/svg/ea_emitter/compartment/constraints"
+        autoload :Marker, "ea/svg/ea_emitter/compartment/marker"
         autoload :PackageContents, "ea/svg/ea_emitter/compartment/package_contents"
         autoload :InstanceUnderline, "ea/svg/ea_emitter/compartment/instance_underline"
         autoload :InstanceSlots, "ea/svg/ea_emitter/compartment/instance_slots"
@@ -34,6 +35,7 @@ module Ea
           Header,
           HeaderDivider,
           StereotypeIcon,
+          Marker,
           Attributes,
           Operations,
           EnumLiterals,

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

@@ -21,6 +21,7 @@ module Ea
                       :attr_lines_count, :op_lines_count,
                       :tagged_values_count,
                       :constraints_count,
+                      :marker_count,
                       :enum_literals_count,
                       :header_top_padding, :header_line_offset,
                       :divider_offset, :attr_line_offset,
@@ -30,6 +31,7 @@ module Ea
                           attr_lines_count:, op_lines_count:,
                           tagged_values_count:,
                           constraints_count: 0,
+                          marker_count: 0,
                           enum_literals_count: 0,
                           header_top_padding: 12,
                           header_line_offset: 6,
@@ -43,6 +45,7 @@ module Ea
             @op_lines_count = op_lines_count
             @tagged_values_count = tagged_values_count
             @constraints_count = constraints_count
+            @marker_count = marker_count
             @enum_literals_count = enum_literals_count
             @header_top_padding = header_top_padding
             @header_line_offset = header_line_offset
@@ -67,6 +70,29 @@ module Ea
           end
 
           def attr_first_y
+            base = raw_attr_first_y
+            return base unless marker_count.to_i.positive?
+
+            # EA renders the {root}/{leaf} marker compartment BETWEEN
+            # the header divider and the attributes: its rows occupy
+            # (attr_base - 9) onward at the 13px pitch, and attributes
+            # shift down one row per marker line. Real OCL constraints
+            # do NOT shift attributes — they render trailing.
+            # Corpus-verified (TK_PositionType: name +13 {root} +22
+            # first-attr; MD_Identification keeps attrs at +22 despite
+            # carrying OCL constraints).
+            base + (size + 6) * marker_count
+          end
+
+          # First marker-line baseline: one row slot above where
+          # attributes would start without markers.
+          def marker_first_y
+            return nil unless marker_count.to_i.positive?
+
+            raw_attr_first_y - 9
+          end
+
+          def raw_attr_first_y
             return bounds.y + size + (header_top_padding || 12) + 12 unless divider_y
 
             divider_y + size + (attr_first_offset || 7)
@@ -106,15 +132,19 @@ module Ea
 
           # Tagged values appear after attributes (or after ops if
           # present). EA does not emit a separate divider — the
-          # italic "tags" header marks the compartment.
+          # italic "tags" header marks the compartment. Constraints
+          # render ABOVE the attributes (constraints_first_y), not
+          # here.
           def tagged_value_first_y
-            return nil unless tagged_values_count.to_i.positive? || constraints_count.to_i.positive?
+            return nil unless tagged_values_count.to_i.positive? ||
+                              constraints_count.to_i.positive?
 
             content_bottom_y + size + 5
           end
 
           # The lowest content edge among attributes, enum literals,
-          # and operations — the anchor for trailing compartments.
+          # operations, and constraints — the anchor for trailing
+          # compartments and the autosize height.
           def content_bottom_y
             bottoms = [attr_bottom_y]
             bottoms << enum_literals_bottom_y if enum_literals_count.to_i.positive?

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

@@ -5,47 +5,31 @@ module Ea
     module EaEmitter
       module Element
         # Emits the constraints compartment text `<g>`. EA renders
-        # constraints as a sub-compartment with an italic "constraints"
-        # header followed by `{name}` lines:
-        #
-        #   <text style="...font-style:italic;...">constraints</text>
-        #   <text style="...font-style:normal;...">{pattern}</text>
+        # each constraint as a bare "{name}" line — no caption —
+        # RIGHT-ALIGNED to the element box's right edge at the 13px
+        # compartment pitch, seated between the header divider and
+        # the attribute rows. Corpus-verified (TK_PositionType /
+        # TK_Position: "{root}" x + textLength lands exactly on the
+        # box right edge).
         class ConstraintRenderer
-          HEADER_TEXT = "constraints"
-          HEADER_X_OFFSET = 5
-          LINE_X_OFFSET = 5
-
           def self.render(constraints, bounds:, first_y:, family:, size:,
                           fill: "#000000")
-            line_h = size + 4
-            text_blocks = []
-            text_blocks << build_text(
-              bounds.x + centered_x_offset(bounds, size), first_y,
-              HEADER_TEXT, family, size, fill, style: "italic"
-            )
-            constraints.each_with_index do |constraint, idx|
-              y = first_y + ((idx + 1) * line_h)
-              text_blocks << build_text(
-                bounds.x + LINE_X_OFFSET, y,
-                "{#{constraint.name}}", family, size, fill
-              )
+            line_h = size + 6
+            text_blocks = constraints.each_with_index.map do |constraint, idx|
+              content = "{#{constraint.name}}"
+              x = bounds.x + bounds.width -
+                  TextRenderer.estimate_width(content, size, nil,
+                                              family: family).round
+              build_text(x, first_y + idx * line_h, content, family, size, fill)
             end
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
-          def self.build_text(x, y, content, family, size, fill, style: "normal")
+          def self.build_text(x, y, content, family, size, fill)
             TextRenderer.new(content: content, x: x, y: y,
-                              family: family, size: size, fill: fill,
-                              style: style).to_svg
+                              family: family, size: size, fill: fill).to_svg
           end
           private_class_method :build_text
-
-          def self.centered_x_offset(bounds, size)
-            text_width = HEADER_TEXT.length * (size / 2)
-            centered = (bounds.width / 2 - text_width / 2).floor
-            [HEADER_X_OFFSET, centered].max
-          end
-          private_class_method :centered_x_offset
         end
       end
     end

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

@@ -9,15 +9,18 @@ module Ea
         # Package as this folder-like silhouette regardless of diagram
         # type.
         #
-        # Layout (element bounds cover tab + body together):
+        # Layout (element bounds cover tab + body together; the tab
+        # occupies the TOP of the stored rect — corpus-verified
+        # against EA-published package polygons, single tab 20px and
+        # stereotype tab 36px, both inside):
         #
         #   ┌───┐
-        #   │tab│   ← top TAB_HEIGHT_SINGLE rows ABOVE element bounds;
-        #   │   │     when a stereotype is present, the tab grows to
-        #   └───┴──────────┐  TAB_HEIGHT_DOUBLE rows and extends INTO
-        #   │               │   the bounds; the name renders bold,
-        #   │     body      │   left-aligned. The body always starts
-        #   │               │   where the tab ends.
+        #   │tab│   ← top TAB_HEIGHT rows of the bounds;
+        #   │   │     36px when a stereotype is present
+        #   ├───┴──────────┐
+        #   │               │  the name renders bold, left-aligned;
+        #   │     body      │  the body always starts where the
+        #   │               │  tab ends
         #   └───────────────┘
         #
         class PackageShapeRenderer
@@ -128,11 +131,9 @@ module Ea
             tab_top_y + TAB_LABEL_Y_OFFSET
           end
 
-          # Tab anchored 20px above the bounds top — matches EA's
-          # folder silhouette regardless of whether the tab holds one
-          # line or two.
+          # Tab occupies the top of the stored rect.
           def tab_top_y
-            bounds.y - TAB_HEIGHT_SINGLE
+            bounds.y
           end
 
           def tab_height
@@ -153,12 +154,9 @@ module Ea
             ]
           end
 
-          # Body extends from tab.bottom to (bounds.bottom - 20px
-          # bottom margin). Total body height = bounds.height -
-          # tab_height (because tab takes (tab_height - 20) from the
-          # top of the bounds plus 20 above the bounds).
+          # Body extends from the tab bottom to the bounds bottom.
           def body_height(body_top)
-            bounds.y + bounds.height - TAB_HEIGHT_SINGLE - body_top
+            bounds.y + bounds.height - body_top
           end
 
           def tab_points

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

@@ -86,29 +86,35 @@ module Ea
                                            tagged_values_for(classifier).size,
                                            header_lines,
                                            constraints_count: constraints_for(classifier).size,
+                                           marker_count: marker_lines_for(classifier).size,
                                            enum_literals_count: enum_literals_for(classifier).size)
-          # 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.
+          # EA suppresses the whole attribute compartment when its
+          # rows do not fit the stored box height (never truncates
+          # rows) - the AOS box on CityFurniture hides its
+          # association property this way. The gate compares the last
+          # baseline + text descent (~4px) against the box bottom:
+          # TK_PositionType keeps 7 rows ending 6px above the bottom,
+          # while a 13px-tighter box loses them all.
           if attr_lines.any? &&
-             geometry.attr_bottom_y.to_i + size > bounds.y + bounds.height
+             geometry.attr_bottom_y.to_i + 4 > bounds.y + bounds.height
             attr_lines = []
             geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                              tagged_values_for(classifier).size,
                                              header_lines,
                                              constraints_count: constraints_for(classifier).size,
+                                           marker_count: marker_lines_for(classifier).size,
                                            enum_literals_count: enum_literals_for(classifier).size)
           end
           # EA suppresses the operations compartment when its rows
           # overflow the stored box height (same rule as attributes).
           if op_lines.any? && geometry.op_first_y &&
-             geometry.op_bottom_y.to_i + size > bounds.y + bounds.height
+             geometry.op_bottom_y.to_i + 4 > bounds.y + bounds.height
             op_lines = []
             geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                              tagged_values_for(classifier).size,
                                              header_lines,
                                              constraints_count: constraints_for(classifier).size,
+                                           marker_count: marker_lines_for(classifier).size,
                                            enum_literals_count: enum_literals_for(classifier).size)
           end
           RenderContext.new(
@@ -127,6 +133,7 @@ module Ea
             enum_literals: enum_literals_for(classifier),
             tagged_values: element.show_tagged_values ? tagged_values_for(classifier) : [],
             constraints: constraints_for(classifier),
+            marker_lines: marker_lines_for(classifier),
             package_content_lines: package_content_lines_for(model_element),
             geometry: geometry,
             theme: theme,
@@ -139,13 +146,15 @@ module Ea
 
         def compartment_geometry(bounds, size, attr_lines, op_lines,
                                  tagged_count, header_lines,
-                                 constraints_count: 0, enum_literals_count: 0)
+                                 constraints_count: 0, marker_count: 0,
+                                 enum_literals_count: 0)
           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,
                                    constraints_count: constraints_count,
+                                   marker_count: marker_count,
                                    enum_literals_count: enum_literals_count,
                                    header_top_padding: header_padding_for(header_lines),
                                    header_line_offset: theme.compartments.header_line_offset,
@@ -193,12 +202,20 @@ module Ea
           classifier.tagged_values || []
         end
 
+        # Real OCL constraints render trailing, after the content
+        # compartment; the {root}/{leaf} marker renders its own
+        # compartment between the divider and the attributes.
         def constraints_for(classifier)
           return [] unless classifier.is_a?(Ea::Model::Classifier)
 
+          classifier.constraints || []
+        end
+
+        def marker_lines_for(classifier)
+          return [] unless classifier.is_a?(Ea::Model::Classifier)
+
           marker_line = root_leaf_marker_for(classifier)
-          marker = marker_line ? [marker_constraint(marker_line)] : []
-          marker + (classifier.constraints || [])
+          marker_line ? [marker_constraint(marker_line)] : []
         end
 
         # EA renders the element's Root/Leaf checkboxes as {root},

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

@@ -16,7 +16,7 @@ module Ea
         :fill, :stroke, :stroke_width, :text_fill,
         :family, :size, :size_unit,
         :header_lines, :attr_lines, :op_lines,
-        :enum_literals, :tagged_values, :constraints,
+        :enum_literals, :tagged_values, :constraints, :marker_lines,
         :package_content_lines,
         :geometry, :theme, :canvas, :diagram, :model_index,
         :off_canvas_parent_name,

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.18"
+  VERSION = "0.6.20"
 end

data/lib/tasks/fonts.rake

@@ -3,30 +3,35 @@
 require "ea/fonts/metrics"
 
 namespace :fonts do
-  desc "Validate the shipped Carlito metrics against Fontist-resolved TTFs"
+  desc "Validate the shipped font metrics against Fontist-resolved TTFs"
   task :validate do
-    files = Ea::Fonts::Metrics.carlito_font_files
-    abort "Carlito not resolvable via Fontist — install it first" if files.empty?
-
     shipped = JSON.parse(File.read(Ea::Fonts::Metrics::DATA_PATH))["advance"]
     style_key = { "regular" => "regular", "bold" => "bold",
                   "italic" => "italic", "bold_italic" => "bold_italic",
                   "bolditalic" => "bold_italic" }
     drift = []
 
-    files.each do |style, path|
-      table = shipped[style_key[style.downcase]]
-      actual = Ea::Fonts::Metrics.advances_from_font(path)
-      missing = actual.keys.count { |cp| table[format("U+%04X", cp)].nil? }
-      puts "  (shipped table lacks #{missing} of #{actual.size} codepoints — skipped)"
-      actual.each do |cp, adv|
-        key = format("U+%04X", cp)
-        ours = table[key]
-        next if ours.nil? || (ours - adv).abs <= 0.0005
+    shipped.keys.each do |family|
+      files = Ea::Fonts::Metrics.font_files_for(family)
+      if files.empty?
+        puts "#{family}: NOT RESOLVABLE VIA FONTIST — skipped"
+        next
+      end
+
+      files.each do |style, path|
+        table = shipped[family][style_key[style.downcase]] || {}
+        actual = Ea::Fonts::Metrics.advances_from_font(path)
+        missing = actual.keys.count { |cp| table[format("U+%04X", cp)].nil? }
+        puts "  (shipped #{family}/#{style} table lacks #{missing} of #{actual.size} codepoints — skipped)"
+        actual.each do |cp, adv|
+          key = format("U+%04X", cp)
+          ours = table[key]
+          next if ours.nil? || (ours - adv).abs <= 0.0005
 
-        drift << format("%s %s: json=%s font=%s", style, key, ours, adv)
+          drift << format("%s/%s %s: json=%s font=%s", family, style, key, ours, adv)
+        end
+        puts "#{family}/#{style}: #{path} — #{actual.size} codepoints checked"
       end
-      puts "#{style}: #{path} — #{actual.size} codepoints checked"
     end
 
     if drift.empty?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.18
+  version: 0.6.20
 platform: ruby
 authors:
 - Ribose Inc.
@@ -884,6 +884,7 @@ files:
 - lib/ea/svg/ea_emitter/compartment/header_divider.rb
 - lib/ea/svg/ea_emitter/compartment/instance_slots.rb
 - lib/ea/svg/ea_emitter/compartment/instance_underline.rb
+- lib/ea/svg/ea_emitter/compartment/marker.rb
 - lib/ea/svg/ea_emitter/compartment/note_body.rb
 - lib/ea/svg/ea_emitter/compartment/note_text.rb
 - lib/ea/svg/ea_emitter/compartment/operations.rb