ea 0.6.34 → 0.6.36

data/lib/ea/fonts/metrics.rb

@@ -91,7 +91,7 @@ module Ea
       end
 
       # EA's scale factor varies by point size (GDI quantization):
-      # Carlito regular fits 1.390 at 7pt but 1.432 at 9pt. Sizes
+      # Carlito regular fits 1.390 at 7pt but 1.440 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)

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

@@ -59,7 +59,27 @@ module Ea
         # 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).
+        # 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 subtitle_points
+          pts = []
+          (diagram.elements || []).each do |e|
+            primary = e.bounds || e.image_bounds
+            next unless primary
+            next unless subtitle_extends_below?(e)
+
+            pts << [primary.x, primary.y + primary.height +
+                                 SUBTITLE_CANVAS_EXTRA]
+          end
+          pts
+        end
+
         def element_points
           pts = []
           (diagram.elements || []).each do |e|
@@ -67,6 +87,10 @@ module Ea
             if primary
               pts << [primary.x, primary.y]
               pts << [primary.x + primary.width, primary.y + primary.height]
+              if subtitle_extends_below?(e)
+                pts << [primary.x, primary.y + primary.height +
+                                     SUBTITLE_CANVAS_EXTRA]
+              end
             end
             if e.bounds && e.image_bounds
               ib = e.image_bounds
@@ -76,6 +100,24 @@ module Ea
           end
           pts
         end
+
+        # Mirrors Compartment::PackageFromParent's render conditions:
+        # the subtitle draws only on ShowForeign diagrams for a
+        # placed package whose parent differs from the diagram's
+        # package.
+        def subtitle_extends_below?(element)
+          return false unless model_index
+          return false unless diagram.show_foreign
+
+          pkg = model_index[element.model_element_ref]
+          return false unless pkg.is_a?(Ea::Model::Package)
+
+          parent_id = pkg.parent_id
+          return false if parent_id.nil? || parent_id.empty?
+          return false if parent_id == diagram.package_id
+
+          model_index[parent_id].is_a?(Ea::Model::Package)
+        end
       end
     end
   end

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

@@ -42,6 +42,33 @@ module Ea
           new(min_x: min_x, min_y: min_y, width: width, height: height)
         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
+        # canvas from drawn extents, so diagrams whose lowest/rightmost
+        # element grew get a taller/wider canvas than the stored-rect
+        # first pass provides.
+        def self.from_drawn(diagram, drawn_bounds, model_index: nil)
+          base = BoundsCalculator.new(diagram, model_index: model_index)
+          pts = []
+          drawn_bounds.each_value do |b|
+            pts << [b.x, b.y]
+            pts << [b.x + b.width, b.y + b.height]
+          end
+          extra = base.send(: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
+          max_y = (pts + extra).map(&:last).max || 0
+          return from(diagram, model_index: model_index) if pts.empty?
+
+          new(min_x: min_x, min_y: min_y,
+              width: (max_x - min_x) + BoundsCalculator::INSET_LEFT +
+                     BoundsCalculator::INSET_RIGHT,
+              height: (max_y - min_y) + BoundsCalculator::INSET_TOP +
+                      BoundsCalculator::INSET_BOTTOM)
+        end
+
         def view_box
           "0 0 #{width} #{height}"
         end

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

@@ -21,11 +21,25 @@ module Ea
 
         def render
           canvas = Canvas.from(diagram, model_index: model_index)
-          layers = LayerSequencer.new(diagram, model_index: model_index,
-                                        canvas: canvas, frame: frame,
-                                        document: document)
-                                  .layers
-                                  .reject { |s| s.nil? || s.empty? }
+          seq = LayerSequencer.new(diagram, model_index: model_index,
+                                   canvas: canvas, frame: frame,
+                                   document: document)
+          seq.layers
+          # Second pass over the DRAWN extents: grown classifiers and
+          # autosized packages can exceed the stored-rect canvas EA
+          # sizes from drawn extents. Skip when the first pass already
+          # covers the drawn extents (the common case).
+          grown = seq.drawn_bounds
+          if grown && grown.values.any? &&
+             exceeds?(canvas, grown.values)
+            canvas = Canvas.from_drawn(diagram, grown,
+                                       model_index: model_index)
+            seq = LayerSequencer.new(diagram, model_index: model_index,
+                                     canvas: canvas, frame: frame,
+                                     document: document)
+            seq.layers
+          end
+          layers = seq.layers.reject { |s| s.nil? || s.empty? }
           image_layer = emit_images
           layers << image_layer if image_layer
 
@@ -55,6 +69,16 @@ module Ea
           %(<g id="images">\n#{fragments.join("\n")}\n</g>)
         end
 
+        # True when any drawn bound falls outside the stored-rect
+        # canvas content area.
+        def exceeds?(canvas, bounds)
+          bounds.any? do |b|
+            b.x < canvas.min_x || b.y < canvas.min_y ||
+              b.x + b.width > canvas.min_x + canvas.width ||
+              b.y + b.height > canvas.min_y + canvas.height
+          end
+        end
+
         def render_image(image)
           svg = Ea::Image::EmfRenderer.render(image.bytes)
           return nil unless svg

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.34"
+  VERSION = "0.6.36"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.34
+  version: 0.6.36
 platform: ruby
 authors:
 - Ribose Inc.