ea 0.6.61 → 0.6.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb774d8053e789ef6200fc5c77c811166ce44308cbfe52c31255ab6c7f404c1d
-  data.tar.gz: 15e26d6ecded00bea2bcedf20a03ac6ce94f3fdfd63dbba6f5357e85aae09969
+  metadata.gz: e6f6d084b7fd0042b8f31d006ed91d5fbc00c18d82937cd1ee5f5b6a6a8e2340
+  data.tar.gz: 6a93141b935afeac3c9409e933795100d5207a4ce532c3634906a174b7ce8c6e
 SHA512:
-  metadata.gz: d33ce1e55c5904c77871d2cb2805e21f0326457b77ef567f73952dab004d92fd10692b547e61bf9c63fff7d35e619ce68dfc5646c22cf5e5a732fc76c7bfc00c
-  data.tar.gz: 5ccac30a04cbeb1e4792473e6a674865d5bb1d1ffa56a271f9709c35d0bdd9488dd1dff5540ed6fc65bda57e175f42618d5dd3cf6521068f05fad5479a7520b0
+  metadata.gz: f4ff485fff168ca3d18ee168d1fa8f3c2acc168d8eb748cedd17c356b98ff8b9abea4b03432c5d3643c956025f358e25a7783cd24806e4e20f494df914992851
+  data.tar.gz: 9351c617930b3c3c54e74b98dc7da68ec8fe12d2031daf28cf0e0a99d0ca7c35f20fc49e85ca726634f9d7c86003b201f3dd808d00d5bc3ed1e7a0e8bc31a96d

data/lib/ea/fonts/metrics.rb

@@ -53,16 +53,43 @@ module Ea
 
       # Width of `text` in EA's exported SVG units for the given pt
       # size, or nil when the family is not metric-compatible.
+      #
+      # EA's GDI driver quantizes each glyph advance to an integer
+      # pixel count at the logical font height H = round(pt * 10/7)
+      # (Carlito: 7pt -> H10, 9pt -> H13) and the published
+      # textLength is the SUM of those per-glyph integers - corpus
+      # fitted to 97-100% exact on 10k Carlito texts (bold 7pt
+      # 1666/1671). The legacy sum-then-round model matched only 27%.
       def text_length(text, size_pt, family: nil, weight: nil, style: nil)
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
-        latin, cjk_count = split_advance(text, family: family,
-                                                weight: weight, style: style)
-        (latin * size_pt.to_f * factor_for(family, size_pt, weight, style) +
+        resolved = resolve_family(family)
+        if GDI_HEIGHT_FAMILIES.include?(resolved)
+          height = (size_pt.to_f * 10 / 7).round
+          table = table_for(family, weight, style)
+          latin = 0
+          cjk_count = 0
+          text.each_char do |ch|
+            if cjk?(ch.ord)
+              cjk_count += 1
+            else
+              latin += ((table[cp_key(ch)] || DEFAULT_ADVANCE) * height).round
+            end
+          end
+          return latin + cjk_count * CJK_ADVANCE * size_pt.to_f
+        end
+
+        _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
 
+      # Families whose EA driver quantizes per-glyph advances
+      # (fitted from published textLengths).
+      GDI_HEIGHT_FAMILIES = %w[Carlito].freeze
+
       def supported_family?(family)
         !resolve_family(family).nil?
       end

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

@@ -128,6 +128,29 @@ module Ea
                                                                 off_canvas_parent_name: parent_name,
                                                                 foreign_package_name: foreign_package_name_for(classifier),
                                                                 suppress_stereotypes: suppress_stereotypes?) : []
+          # Regenerated contexts (SuppressFOC=0) re-size EVERY box to
+          # fit ALL content (7F10BFBD: Set enum box stored 70x59 ->
+          # EA 165x223 with all six literals unwrapped): width =
+          # max(stored, title + pad_t, widest row + 8), height likewise
+          # grows via the standard content growth. Frozen contexts
+          # (SuppressFOC=1) keep stored sizes and wrap.
+          if regenerated_context? && classifier.is_a?(Ea::Model::Classifier) &&
+             !classifier.is_a?(Ea::Model::Package)
+            preview_lines = []
+            if show_attributes? && attributes_visible?(element) &&
+               !classifier.is_a?(Ea::Model::Interface)
+              preview_lines += Element::AttributeRenderer.lines_for(
+                classifier, lookup: attribute_lookup,
+                exclude_association_ids: drawn_association_ids
+              )
+            end
+            if show_operations? && operations_visible?(element)
+              preview_lines += Element::OperationRenderer.lines_for(classifier)
+            end
+            bounds = context_resized_bounds(bounds, classifier, size, family,
+                                            preview_lines)
+          end
+
           is_classifier = classifier.is_a?(Ea::Model::Classifier)
           # Interfaces DO render attribute compartments when they own
           # attribute rows (936AA434/Surface lists its nine 19107
@@ -143,6 +166,7 @@ module Ea
                          []
                        end
           op_lines = if is_classifier && show_operations? && operations_visible?(element)
+            $stderr.puts "DBG ops: show=#{show_operations?} vis=#{operations_visible?(element)} cls=#{classifier.class} nops=#{classifier.operations.to_a.size}"
                         Element::OperationRenderer.lines_for(classifier)
                       else
                         []
@@ -177,8 +201,24 @@ module Ea
                                            enum_literals_count: enum_row_count_for(classifier))
           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 &&
+          # overflow the stored box height (same rule as attributes)
+          # - EXCEPT on regenerated contexts, where EA GROWS the box
+          # to fit every row instead (7F10BFBD: Set stored 70x59 ->
+          # drawn 165x223 with all twelve operations).
+          if regenerated_context? && op_lines.any? && geometry.op_first_y &&
+             geometry.op_bottom_y.to_i > bounds.y + bounds.height
+            bounds = Ea::Model::Bounds.new(
+              x: bounds.x, y: bounds.y,
+              width: bounds.width,
+              height: geometry.op_bottom_y.to_i + 8 - bounds.y
+            )
+            geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
+                                             tagged_values_for(classifier).size,
+                                             header_lines, classifier: classifier,
+                                             constraints_count: constraints_for(classifier).size,
+                                           marker_count: marker_lines_for(classifier).size,
+                                           enum_literals_count: enum_row_count_for(classifier))
+          elsif op_lines.any? && geometry.op_first_y &&
              geometry.op_bottom_y.to_i > bounds.y + bounds.height
             op_lines = []
             geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
@@ -198,7 +238,12 @@ module Ea
           # position even with zero operations), so it must stay out
           # of the max.
           grown_bottom = geometry.content_bottom_y.to_i
-          if attr_lines.any? && grown_bottom.positive? &&
+          # Enum literals grow the box too (7F10BFBD 'Context Diagram:
+          # Bag': Set enum box stored h59 -> EA 223 fitting six
+          # literals); op-only boxes keep the no-growth behavior
+          # (op_bottom_y is a divider sentinel, not content).
+          if (attr_lines.any? || enum_literals_for(classifier).any?) &&
+             grown_bottom.positive? &&
              grown_bottom + 8 > bounds.y + bounds.height
             bounds = Ea::Model::Bounds.new(
               x: bounds.x, y: bounds.y,
@@ -419,6 +464,34 @@ module Ea
         # classifier lives in a different package than the diagram
         # (descendant packages included). Corpus-verified (450
         # diagrams): ShowForeign=0 renders plain everywhere.
+        def regenerated_context?
+          diagram.name.to_s.downcase.start_with?("context diagram") &&
+            diagram.style_ex.to_s !~ /SuppressFOC=1/
+        end
+
+        TITLE_PAD = 18
+
+        def context_resized_bounds(bounds, classifier, size, family, rows)
+          label = classifier.name.to_s
+          pkg = foreign_package_name_for(classifier)
+          label = "#{pkg}::#{label}" if pkg
+          title_w = TextRenderer.estimate_width(
+            label, size, nil, family: family, weight: "700"
+          ).round
+          pad = title_w.odd? ? TITLE_PAD : 16
+          row_w = rows.map do |line|
+            line = line.sub(/\A«[^»]*»\z/, "")
+            TextRenderer.estimate_width(
+              line, size, nil, family: family, weight: "400"
+            ).round + 8
+          end.max.to_i
+          needed = [bounds.width, title_w + pad, row_w].max
+          return bounds if needed <= bounds.width
+
+          Ea::Model::Bounds.new(x: bounds.x, y: bounds.y,
+                                width: needed, height: bounds.height)
+        end
+
         def foreign_package_name_for(classifier)
           return nil unless diagram.show_foreign
           return nil unless classifier.is_a?(Ea::Model::Classifier)

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.61"
+  VERSION = "0.6.63"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.61
+  version: 0.6.63
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-07 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model