ea 0.6.121 → 0.6.122

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27202e3cefb07cca1a7bc22923a692ef3eb882be925e4ec8c31962518620c07
-  data.tar.gz: c31f63e7b1d97192c503d2a6b1464067aaff21dd06d8f716eeb83abc0f42a858
+  metadata.gz: 134a5c15aeb52f545cffe73a1541d36c404bc73daef03794c3cc0289744c0364
+  data.tar.gz: 231fad8c18f4f7ab8b72bc7e3f4b23652f2b44dfd5b9e6b54d8377cc3e4625d9
 SHA512:
-  metadata.gz: 2a22e4c323e4e34f1e9b65ed0b3881dc6f8593d4e36546e64550cf050aeef603373d656850ae88d5992a2dc330371203fa07f6fab495378093a1c409e510114f
-  data.tar.gz: 3923190f152ee52b99476f64c97e0201b783beea6291b18e8b1bb28967ef9a1f09188cf7bbad41d8a4339434471ea9e577d73cc4c1135f2dc88f0b1b1fdf650b
+  metadata.gz: 210b2520ec8a7d00782cc06b65a27ff3b391c611a4994b97aabc3281528db9e1356a96cd1b07a8734533f50c8c1b9a9e82e74576cf2a25f533c442e163ea09e4
+  data.tar.gz: d46dd157918d5fa7a1d9884d6cdba517a4d3fc911894c6f800d2cece0fdb62e2b5a09dfa030bd80cc604fe5ab2a91a310d86b5c9893c54b81cad2536200563ac

data/lib/ea/model/diagram_element.rb

@@ -22,6 +22,8 @@ module Ea
       attribute :line_width, :integer
       attribute :font_family, :string
       attribute :font_size, :integer
+      # nil: unspecified provenance; true: source delegates to default resolution.
+      attribute :font_size_inherited, :boolean
       attribute :font_logical_height, :integer # original GDI pixel height before point normalization
       attribute :font_size_unit, :string # source font size unit, before theme fallback
       attribute :font_bold, :boolean
@@ -55,6 +57,7 @@ module Ea
         map "lineWidth", to: :line_width
         map "fontFamily", to: :font_family
         map "fontSize", to: :font_size
+        map "fontSizeInherited", to: :font_size_inherited, render_default: true
         map "fontSizeUnit", to: :font_size_unit
         map "fontLogicalHeight", to: :font_logical_height
         map "fontBold", to: :font_bold, render_default: true

data/lib/ea/sources/qea/diagram_builder.rb

@@ -138,6 +138,7 @@ module Ea
             style: style_hash,
             font_family: presence(font_style[:font]),
             font_size: font_size_from(font_style),
+            font_size_inherited: font_size_from(font_style).nil?,
             font_size_unit: "pt",
             font_logical_height: font_logical_height_from(font_style),
             font_bold: truthy?(style_hash[:bold]),

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

@@ -15,7 +15,7 @@ module Ea
                 context.bounds,
                 legend: context.model_element.legend,
                 family: context.family,
-                item_font: { size: context.element&.font_size&.nonzero?, unit: context.size_unit,
+                item_font: { size: legend_item_size(context), unit: context.size_unit,
                              logical_height: context.logical_height }
               )
             elsif context.model_element.is_a?(Ea::Model::Note)
@@ -54,6 +54,17 @@ module Ea
             end
           end
 
+          def legend_item_size(context)
+            element = context.element
+            return unless element
+            return element.font_size if element.font_size&.nonzero?
+
+            # Parsed source defaults inherit; unspecified callers keep 9pt.
+            inherited = element.font_size_inherited || element.style&.fetch(:fontsz, nil).to_s == "0"
+            context.size if inherited
+          end
+          private_class_method :legend_item_size
+
           # A Text element with LegendOpts= renders as the legend
           # block rather than a folder silhouette. Dispatch on the
           # presence of the attached Legend payload.

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

@@ -50,14 +50,14 @@ module Ea
         end
 
         def layers
-          widths = paths_with_widths
+          styles = paths_with_styles
 
           if grouped
-            widths.group_by(&:first).map do |width, entries|
-              line_layer(width, entries.map(&:last).join("\n  "))
+            styles.group_by(&:first).map do |(width, dashed), entries|
+              line_layer(width, dashed, entries.map(&:last).join("\n  "))
             end
           else
-            widths.map { |width, path| line_layer(width, path) }
+            styles.map { |(width, dashed), path| line_layer(width, dashed, path) }
           end
         end
 
@@ -73,16 +73,29 @@ module Ea
 
         private
 
-        def paths_with_widths
+        def paths_with_styles
           visible_connectors.filter_map do |connector|
             path = path_for(connector)
-            [self.class.stroke_width_for(connector, stroke_width), path] if path
+            next unless path
+
+            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)], path]
           end
         end
 
-        def line_layer(width, body)
-          Layer.new(style_key: self.class.layer_key(LINE_STYLE_KEY, width, stroke_width),
-                    style: line_style(width), body: body)
+        def line_layer(width, dashed, body)
+          key = dashed ? :connector_line_dashed : LINE_STYLE_KEY
+          style = line_style(width)
+          style += ";stroke-dasharray:6,3" if dashed
+          Layer.new(style_key: self.class.layer_key(key, width, stroke_width),
+                    style: style, body: body)
+        end
+
+        def dashed?(connector)
+          return true if connector.connector_type == "Dependency"
+          return false unless connector.connector_type == "Package"
+
+          relationship = model_index && model_index[connector.relationship_ref]
+          relationship&.stereotype == "import"
         end
 
         def visible_connectors

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

@@ -10,13 +10,12 @@ module Ea
         # type.
         #
         # 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):
+        # occupies the TOP of the stored rect, with its height adjusted
+        # by the font line height for each header row):
         #
         #   ┌───┐
-        #   │tab│   ← top TAB_HEIGHT rows of the bounds;
-        #   │   │     36px when a stereotype is present
+        #   │tab│   ← one name row, or two rows with a stereotype
+        #   │   │
         #   ├───┴──────────┐
         #   │               │  the name renders bold, left-aligned;
         #   │     body      │  the body always starts where the
@@ -148,7 +147,11 @@ module Ea
           end
 
           def tab_height
-            has_stereotype? ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+            nominal_height = has_stereotype? ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+            rows = has_stereotype? ? 2 : 1
+            # Preserve the nominal padding while each row follows the same
+            # font line height used to place the package header text.
+            nominal_height + rows * (tab_line_height - TAB_LABEL_Y_OFFSET)
           end
 
           def body_points

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

@@ -152,8 +152,10 @@ module Ea
                         []
                       end
           # Titles wrap; content rows grow the drawn box to fit their insets.
-          row_w = [row_content_width(attr_lines, 5, size, family, logical_height),
-                   row_content_width(op_lines, 3, size, family, logical_height),
+          row_w = [row_content_width(attr_lines, 5, size, family,
+                                     logical_height: logical_height,
+                                     content_x_offset: attribute_content_x_offset(size, family, size_unit)),
+                   row_content_width(op_lines, 3, size, family, logical_height: logical_height),
                    Compartment::EnumLiterals.content_width(
                      enum_literals_for(classifier),
                      theme: theme, size: size, family: family,
@@ -249,7 +251,8 @@ module Ea
           # Real attributes grow the DRAWN box past the stored
           # height instead of being dropped (0CABA7D7: stored h44
           # draws at h59). Grown height = last row baseline + EA's
-          # ~8px bottom padding. Render-local: the diagram-level
+          # trailing padding (7px for compact Cambria, 8px otherwise).
+          # Render-local: the diagram-level
           # canvas still derives from stored bounds.
           # content_bottom_y is nil when no compartment has rows;
           # op_bottom_y is NOT a sentinel (it reports the op-divider
@@ -268,7 +271,7 @@ module Ea
             bounds = Ea::Model::Bounds.new(
               x: bounds.x, y: bounds.y,
               width: bounds.width,
-              height: grown_bottom + 8 - bounds.y
+              height: grown_bottom + compartment_bottom_padding(size, family, size_unit) - bounds.y
             )
           end
           RenderContext.new(
@@ -298,18 +301,30 @@ module Ea
           )
         end
 
-        def row_content_width(lines, right_pad, size, family, logical_height)
+        def attribute_content_x_offset(size, family, size_unit)
+          offset = (theme.attribute_spec.content_x_offset || Element::AttributeRenderer::DEFAULT_CONTENT_X_OFFSET) +
+                   2 * (size - 7)
+          offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
+          offset
+        end
+
+        def compartment_bottom_padding(size, family, size_unit)
+          Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit) ? 7 : 8
+        end
+
+        def row_content_width(lines, right_pad, size, family, **font_options)
           return nil if lines.to_a.empty?
 
-          tl = lines.filter_map do |line|
+          lines.filter_map do |line|
             text = line.sub(/\A\S /, "")
-            Ea::Fonts::Metrics.text_length(text, size,
-                                           family: family,
-                                           weight: "400", logical_height: logical_height)&.round
-          end.max
-          return nil unless tl
+            length = Ea::Fonts::Metrics.text_length(text, size,
+                                                    family: family,
+                                                    weight: "400", logical_height: font_options[:logical_height])&.round
+            next unless length
 
-          22 + tl + right_pad
+            offset = line.match?(/\A[-+~#]\s/) ? font_options.fetch(:content_x_offset, 22) : 22
+            offset + length + right_pad
+          end.max
         end
 
         def compartment_geometry(bounds, size, attr_lines, op_lines,

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

@@ -79,6 +79,7 @@ module Ea
               text_pos, mult_pos = tree_positions(end_kind, anchor, role,
                                                   text_pos, mult_pos)
               mult_pos = tree_left_multiplicity(end_kind, heading, anchor, mult_box, mult) || mult_pos
+              text_pos = tree_left_property_role(connector, end_kind, heading, anchor, text_box, role) || text_pos
             elsif mult_box && stored_offsets_zero?(mult_box)
               # Start at the legacy default; measured directional seats
               # below replace it for default Cambria labels.
@@ -210,8 +211,9 @@ module Ea
 
           def source_property_seat?(connector, direction, box)
             phantom_property_box?(connector, direction, box) ||
-              (%i[up left right down].include?(direction) && property_role_box?(box, direction) &&
-                source_property_font?(connector, direction))
+              (%i[up left right down].include?(direction) &&
+                property_role_box?(box, direction, connector.style.to_h) &&
+                source_property_font?(connector, direction, box))
           end
 
           # Phantom outlines carry synthesized zero boxes without alignment.
@@ -392,9 +394,23 @@ module Ea
               [nil, "V"].include?(style[:tree])
           end
 
-          def property_role_box?(box, direction)
-            alignments = direction == :down ? [1] : [0, 1]
-            box && alignments.include?(box["alignment"]) && default_presentation?(box)
+          def property_role_box?(box, direction, style = {})
+            return false unless box && default_presentation?(box)
+            return [0, 1].include?(box["alignment"]) unless direction == :down
+
+            case box["alignment"]
+            when 1 then true
+            when 0 then persisted_plain_down_box?(box, style)
+            else false
+            end
+          end
+
+          # Persisted alignment-0 boxes on untreed routes use the downward
+          # seat, including saved rays; the "OS" route also seats absent boxes.
+          def persisted_plain_down_box?(box, style)
+            return true if orthogonal_stub_route?(style)
+
+            !stored_offsets_zero?(box) && style[:tree].nil?
           end
 
           def property_role_offsets(direction)
@@ -405,26 +421,58 @@ module Ea
             end
           end
 
-          def source_property_font?(connector, direction)
+          def source_property_font?(connector, direction, box)
             source_property_cambria?(connector) &&
-              source_property_route?(connector.style.to_h, direction)
+              source_property_route?(connector.style.to_h, direction, box)
           end
 
           def source_property_cambria?(connector)
             font_family.to_s.casecmp("Cambria").zero? && property_label?(connector, :source)
           end
 
-          def source_property_route?(style, direction)
+          def source_property_route?(style, direction, box)
             case direction
-            when :left then left_property_route?(style)
             when :right then style.values_at(:mode, :lwidth, :tree) == %w[3 2 H]
-            when :down then downward_property_route?(style)
-            else %w[0 2].include?(style[:lwidth]) && style[:tree] != "OS"
+            when :up then upward_property_route?(style)
+            when :left then orthogonal_stub_route?(style) || left_property_route?(style)
+            else downward_source_route?(style, box)
             end
           end
 
+          def downward_source_route?(style, box)
+            [orthogonal_stub_route?(style), lateral_horizontal_route?(style), mode_two_route?(style),
+             downward_property_route?(style), persisted_width_zero_down_box?(box, style)].any?
+          end
+
+          def persisted_width_zero_down_box?(box, style)
+            box["alignment"]&.zero? && !stored_offsets_zero?(box) && style[:stored_association_ray] != true &&
+              style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
+          end
+
+          # Mode 3, width 2 on the horizontal lateral tree.
+          def lateral_horizontal_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == %w[3 2 LH]
+          end
+
+          # Mode 2, width 2 without a tree seats like the other width-2 modes.
+          def mode_two_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == ["2", "2", nil]
+          end
+
+          def upward_property_route?(style)
+            return orthogonal_stub_route?(style) if style[:tree] == "OS"
+
+            %w[0 2].include?(style[:lwidth])
+          end
+
+          # The "OS" route seats its Property roles at the same directional
+          # corner seats as the untreed width-2 route.
+          def orthogonal_stub_route?(style)
+            style.values_at(:mode, :lwidth, :tree) == %w[3 2 OS]
+          end
+
           def left_property_route?(style)
-            downward_property_route?(style) ||
+            downward_property_route?(style) || mode_two_route?(style) ||
               (style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
                 [nil, "H", "LV"].include?(style[:tree]))
           end
@@ -456,6 +504,15 @@ module Ea
             [x + SEAT_X_INSET + width, y + 15] if width
           end
 
+          # An absent source box on a leftward tree leg seats a Property role
+          # at the leftward Property seat, not the rightward tree default.
+          def tree_left_property_role(connector, end_kind, heading, anchor, box, role)
+            return nil unless leg_direction(end_kind, heading) == :left && box&.[]("alignment")&.zero?
+            return nil unless connector.style.to_h.values_at(:mode, :lwidth) == %w[3 2]
+
+            source_property_seat(connector, :left, anchor, box, role)
+          end
+
           # A tree-route source leaving left seats its multiplicity like any
           # other leftward source rather than at the rightward tree default.
           def tree_left_multiplicity(end_kind, heading, anchor, box, mult)

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

@@ -125,7 +125,7 @@ module Ea
         # Unknown faces retain the stored-upward fallback.
         def source_heading(connector, points)
           heading = leg_heading(points)
-          return heading unless points.size == 2 && heading.none?(&:zero?)
+          return heading unless heading.none?(&:zero?) && source_face_route?(connector, points)
 
           box = source_dock_bounds(connector)
           face = box && source_dock_heading(connector, points.first, box)
@@ -134,6 +134,15 @@ module Ea
           stored_upward_heading(connector, heading)
         end
 
+        # Explicit source boxes preserve the heading of a manual bend. An
+        # omitted source box uses the same dock seat as a straight route.
+        def source_face_route?(connector, points)
+          return true if points.size == 2
+
+          boxes = connector.label_boxes || {}
+          end_boxes(boxes, :llt, :llb).nil? && !end_boxes(boxes, :lrt, :lrb).nil?
+        end
+
         # A target dock that clips an axis-aligned stored leg into a slight
         # diagonal keeps the stored leg's direction.
         def target_heading(connector, points)
@@ -150,15 +159,24 @@ module Ea
         # A saved external ray enters the source through the face it first
         # meets, even when the clipped leg then runs back across the box.
         def face_leads_leg?(connector, face, heading, box)
-          anchor = connector.source_anchor
-          if face == [0, 1] && anchor && anchor.y > box.y + box.height &&
-             connector.style.to_h[:stored_association_ray] == true
-            return true
-          end
+          return true if saved_ray_beyond_face?(connector, face, box)
 
           face.zip(heading).any? { |axis, delta| (axis * delta).positive? }
         end
 
+        # A saved ray from beyond the bottom or right face meets that face
+        # first. The top face is excluded: its clipped leg keeps the anchor seat.
+        def saved_ray_beyond_face?(connector, face, box)
+          anchor = connector.source_anchor
+          return false unless anchor && connector.style.to_h[:stored_association_ray] == true
+
+          case face
+          when [0, 1] then anchor.y > box.y + box.height
+          when [1, 0] then anchor.x > box.x + box.width
+          else false
+          end
+        end
+
         def stored_upward_heading(connector, heading)
           return heading unless heading[1].negative?
 

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

@@ -20,6 +20,7 @@ module Ea
                                         anchor: whole_anchor,
                                         base: whole_base)]
             return specs unless whole_at_target
+            return specs if arrow_on_target_diamond?(connector, relationship)
 
             specs.concat(direction_specs(connector, source, target,
                                          before_target, after_source))
@@ -67,6 +68,14 @@ module Ea
             !whole_end_at_source?(connector)
           end
 
+          # EA draws no arrow where a directed, dest-flagged aggregation
+          # would put it on its own target diamond.
+          def self.arrow_on_target_diamond?(connector, relationship)
+            connector.direction == "Source -> Destination" &&
+              dest_flagged?(relationship)
+          end
+          private_class_method :arrow_on_target_diamond?
+
           def self.dest_flagged?(relationship)
             relationship &&
               %w[shared composite].include?(relationship.target_aggregation.to_s)

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

@@ -22,7 +22,7 @@ module Ea
         DIAMOND_HALF_W = 5
         DIAMOND_HALF_H = 10
         TRI_HALF_BASE = 6
-        TRI_HEIGHT = 11
+        TRI_HEIGHT = 16
         # EA's path arrowheads are height 15 corpus-wide, with
         # distinct bases per connector kind: association
         # navigability arrows base 12, dependency arrows base 10
@@ -364,10 +364,10 @@ module Ea
           left_x = tx - ux * DIAMOND_HALF_H - (-uy) * DIAMOND_HALF_W
           left_y = ty - uy * DIAMOND_HALF_H - ux * DIAMOND_HALF_W
           pts = [
-            Canvas.coord(tx), Canvas.coord(ty),
-            Canvas.coord(right_x), Canvas.coord(right_y),
-            Canvas.coord(back_x), Canvas.coord(back_y),
-            Canvas.coord(left_x), Canvas.coord(left_y)
+            Canvas.coord(tx.round), Canvas.coord(ty.round),
+            Canvas.coord(right_x.round), Canvas.coord(right_y.round),
+            Canvas.coord(back_x.round), Canvas.coord(back_y.round),
+            Canvas.coord(left_x.round), Canvas.coord(left_y.round)
           ].join(" ")
           %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
         end
@@ -385,9 +385,9 @@ module Ea
           w2_x = back_x - (-uy) * TRI_HALF_BASE
           w2_y = back_y - ux * TRI_HALF_BASE
           pts = [
-            Canvas.coord(tx), Canvas.coord(ty),
-            Canvas.coord(w1_x), Canvas.coord(w1_y),
-            Canvas.coord(w2_x), Canvas.coord(w2_y)
+            Canvas.coord(tx.round), Canvas.coord(ty.round),
+            Canvas.coord(w1_x.round), Canvas.coord(w1_y.round),
+            Canvas.coord(w2_x.round), Canvas.coord(w2_y.round)
           ].join(" ")
           %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
         end
@@ -404,7 +404,9 @@ module Ea
           w1_y = back_y + ux * ARROW_HALF_BASE
           w2_x = back_x - (-uy) * ARROW_HALF_BASE
           w2_y = back_y - ux * ARROW_HALF_BASE
-          d = "M #{Canvas.coord(w1_x)} #{Canvas.coord(w1_y)} L #{Canvas.coord(tx)} #{Canvas.coord(ty)} L #{Canvas.coord(w2_x)} #{Canvas.coord(w2_y)}"
+          d = "M #{Canvas.coord(w1_x.round)} #{Canvas.coord(w1_y.round)} " \
+              "L #{Canvas.coord(tx.round)} #{Canvas.coord(ty.round)} " \
+              "L #{Canvas.coord(w2_x.round)} #{Canvas.coord(w2_y.round)}"
           %(<path d="#{d}" shape-rendering="auto"/>)
         end
 

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.121"
+  VERSION = "0.6.122"
 end

metadata

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