ea 0.6.121 → 0.6.123

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27202e3cefb07cca1a7bc22923a692ef3eb882be925e4ec8c31962518620c07
-  data.tar.gz: c31f63e7b1d97192c503d2a6b1464067aaff21dd06d8f716eeb83abc0f42a858
+  metadata.gz: d897b1e2165c9993420958c081ee3e2eedebbfbb8ac4db1ea8f160fd45913a3d
+  data.tar.gz: 667e5cce39c543c97f96fd7b64c994d72808daf3bf6a875ae112e0efe4b2623b
 SHA512:
-  metadata.gz: 2a22e4c323e4e34f1e9b65ed0b3881dc6f8593d4e36546e64550cf050aeef603373d656850ae88d5992a2dc330371203fa07f6fab495378093a1c409e510114f
-  data.tar.gz: 3923190f152ee52b99476f64c97e0201b783beea6291b18e8b1bb28967ef9a1f09188cf7bbad41d8a4339434471ea9e577d73cc4c1135f2dc88f0b1b1fdf650b
+  metadata.gz: e8789c4187a4c72534f2e4d17f1caf650e7da1748aa08bed49764fa6fde0dafdfc1bf8c6811ab7a33e31b6da1ffe0a71397b6ca60b1a8c2e7ee0e65a4798368d
+  data.tar.gz: 37bf77d8c14e921888081ee961506f835b5cd0de1bb28de790d5ba848003915922e83c83e2b29d6db0f58141f25dc1d643059f642950ee6cd2028da87d42b42f

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/instance_underline.rb

@@ -5,12 +5,10 @@ module Ea
     module EaEmitter
       module Compartment
         # Instance-name underline for object diagrams. EA draws a
-        # short horizontal line just below each instance name to
-        # denote that it is an instance (UML convention). Rendered
-        # only when the diagram's `diagram_type` is "Object".
+        # short horizontal line below each instance name to denote
+        # that it is an instance (UML convention).
         module InstanceUnderline
-          Y_OFFSET = 2
-          WIDTH_FACTOR = 0.65
+          Y_OFFSET = 1
 
           module_function
 
@@ -19,11 +17,22 @@ module Ea
             return nil unless object_diagram?(context)
             return nil if context.header_lines.empty?
 
-            name_line = context.header_lines.last
-            text = name_line.first.to_s
-            return nil if text.empty?
+            header = Element::HeaderRenderer.line_layout(
+              context.header_lines,
+              bounds: context.bounds,
+              first_y: context.geometry.header_first_y,
+              family: context.family,
+              size: context.size,
+              size_unit: context.size_unit,
+              logical_height: context.logical_height,
+              weight_normal: context.theme.text_weight_normal,
+              weight_bold: context.theme.text_weight_bold,
+              width_factor: context.theme.text_width_factor,
+              line_offset: context.theme.compartments.header_line_offset
+            ).last
+            return nil unless header && !header.text.to_s.empty?
 
-            underline_path(context, text)
+            underline_path(header)
           end
 
           def object_diagram?(context)
@@ -31,18 +40,13 @@ module Ea
           end
           module_function :object_diagram?
 
-          def underline_path(context, text)
-            bounds = context.bounds
-            text_width = TextRenderer.estimate_width(text, context.size,
-                                                     WIDTH_FACTOR)
-            x_start = bounds.x + (bounds.width - text_width) / 2.0
-            y_pos = context.geometry.header_first_y + Y_OFFSET
-            build_path_tag(x_start, y_pos, text_width)
+          def underline_path(header)
+            build_path_tag(header.x, header.y + Y_OFFSET, header.text_length)
           end
           module_function :underline_path
 
-          def build_path_tag(x_start, y_pos, text_width)
-            x_end = x_start + text_width
+          def build_path_tag(x_start, y_pos, text_length)
+            x_end = x_start + text_length
             coords = format_coords(x_start, y_pos, x_end)
             d = "M #{coords[:x1]} #{coords[:y1]} L #{coords[:x2]} #{coords[:y1]}"
             style = "stroke-width:1;stroke-linecap:square;" \

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

@@ -14,6 +14,7 @@ module Ea
           ROW_HEIGHT = 16
           ICON_X_OFFSET = 5
           TEXT_X_OFFSET = 23
+          FIRST_BASELINE_OFFSET = 15
 
           module_function
 
@@ -22,7 +23,7 @@ module Ea
             return nil if rows.nil? || rows.empty?
 
             bounds = context.bounds
-            first_y = context.geometry.attr_first_y
+            first_y = first_baseline(context)
             blocks = rows.each_with_index.flat_map do |row, idx|
               y_top = first_y - 11 + (idx * ROW_HEIGHT)
               y_text = first_y + (idx * ROW_HEIGHT)
@@ -34,6 +35,14 @@ module Ea
             wrap_group(blocks.join("\n"))
           end
 
+          def first_baseline(context)
+            context.bounds.y + Element::PackageShapeRenderer.tab_height_for(
+              stereotype: Shape.package_stereotype(context.model_element),
+              family: context.family, size: context.size, size_unit: context.size_unit
+            ) + FIRST_BASELINE_OFFSET
+          end
+          private_class_method :first_baseline
+
           def wrap_group(body)
             %(<g style="#{group_style}">\n#{body}\n</g>)
           end

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/header_renderer.rb

@@ -11,55 +11,70 @@ module Ea
         # the left edge from text-width approximation since SVG text
         # x= is the start position, not the center).
         class HeaderRenderer
+          HeaderLine = Struct.new(:text, :style, :x, :y, :text_length,
+                                  :weight, :font_style, keyword_init: true)
+
           def self.render(lines, bounds:, first_y:, family:,
                           size:, size_unit: "pt", logical_height: nil,
                           fill: "#000000", weight_normal: 400, weight_bold: 700,
                           stroke_in_text: "#000000", width_factor: 0.612,
                           line_offset: 6)
             logical_height = nil unless size_unit == "pt"
+            layout = line_layout(
+              lines, bounds: bounds, first_y: first_y, family: family,
+                     size: size, size_unit: size_unit, logical_height: logical_height,
+                     weight_normal: weight_normal, weight_bold: weight_bold,
+                     width_factor: width_factor, line_offset: line_offset
+            )
+            text_blocks = layout.map do |line|
+              TextRenderer.new(
+                content: line.text,
+                x: line.x, y: line.y,
+                family: family, size: size, size_unit: size_unit, logical_height: logical_height,
+                weight: line.weight, style: line.font_style, fill: fill,
+                stroke_in_text: stroke_in_text, width_factor: width_factor,
+                text_length: line.text_length
+              ).to_svg
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          # Returns the exact integer placement and width used for each
+          # emitted header line so dependent compartments can align to it.
+          def self.line_layout(lines, bounds:, first_y:, family:, size:,
+                               size_unit: "pt", logical_height: nil,
+                               weight_normal: 400, weight_bold: 700,
+                               width_factor: 0.612, line_offset: 6)
+            logical_height = nil unless size_unit == "pt"
             line_h = Ea::Fonts::Metrics.compartment_line_height(
-              size, family: family, unit: size_unit, offset: line_offset, logical_height: logical_height
+              size, family: family, unit: size_unit, offset: line_offset,
+                    logical_height: logical_height
             )
             ghost_shift = HeaderLines.parent_ghost_gap(lines)
-            text_blocks = lines.each_with_index.map do |(text, style), idx|
-              weight = case style
-                       when :bold, :bold_italic then weight_bold
-                       else weight_normal
-                       end
+            lines.each_with_index.map do |(text, style), idx|
+              weight = %i[bold bold_italic].include?(style) ? weight_bold : weight_normal
               font_style = %i[italic italic_tight bold_italic].include?(style) ? "italic" : "normal"
+              text_length = TextRenderer.estimate_width(
+                text, size, width_factor, family: family, weight: weight,
+                                          style: font_style, logical_height: logical_height
+              ).round
               y = first_y + (idx * line_h) +
                   (idx >= 1 && ghost_shift.positive? ? ghost_shift : 0)
               x = if %i[italic italic_tight].include?(style)
-                    # Parent ghosts end 3px inside the box's right edge.
-                    bounds.x + bounds.width - 3 -
-                      Ea::Svg::EaEmitter::TextRenderer.estimate_width(
-                        text, size, width_factor,
-                        family: family, weight: weight, style: font_style, logical_height: logical_height
-                      ).round
+                    bounds.x + bounds.width - 3 - text_length
                   else
-                    center_x_for(text, bounds, size, width_factor,
-                                 family: family, weight: weight,
-                                 style: font_style, logical_height: logical_height)
+                    center_x_for(text_length, bounds)
                   end
-              TextRenderer.new(
-                content: text,
-                x: x, y: y,
-                family: family, size: size, size_unit: size_unit, logical_height: logical_height,
-                weight: weight, style: font_style, fill: fill,
-                stroke_in_text: stroke_in_text, width_factor: width_factor
-              ).to_svg
+              HeaderLine.new(text: text, style: style, x: x, y: y,
+                             text_length: text_length, weight: weight,
+                             font_style: font_style)
             end
-            %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
           # EA centers text by its INTEGER textLength and floors the
           # resulting x (verified exact against EA-published SVGs).
-          def self.center_x_for(text, bounds, size, width_factor,
-                                family: nil, weight: nil, style: nil, logical_height: nil)
-            len = Ea::Svg::EaEmitter::TextRenderer.estimate_width(
-              text, size, width_factor, family: family, weight: weight, style: style, logical_height: logical_height
-            ).round
-            (bounds.x + (bounds.width - len) / 2.0).floor
+          def self.center_x_for(text_length, bounds)
+            (bounds.x + (bounds.width - text_length) / 2.0).floor
           end
           private_class_method :center_x_for
         end

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

@@ -26,9 +26,10 @@ module Ea
             text_blocks = []
             has_receptions = operations.any?(&:is_reception)
             if has_receptions
+              heading_width = reception_heading_width(family, size, size_unit, logical_height)
               text_blocks << TextRenderer.new(
                 content: "receptions",
-                x: bounds.x + (bounds.width / 2.0) - (8 * size * 0.65) / 2,
+                x: bounds.x + (bounds.width / 2.0) - heading_width / 2.0,
                 y: first_y,
                 family: family, size: size, size_unit: size_unit, logical_height: logical_height,
                 style: "italic", fill: "#000000"
@@ -36,12 +37,14 @@ module Ea
             end
             ops = has_receptions ? operations : operations
             offset = has_receptions ? 1 : 0
+            content_x_offset = CONTENT_X_OFFSET + 2 * (size - 7)
+            content_x_offset -= 1 if Ea::Fonts::Metrics.compact_compartment_font?(size, family: family, unit: size_unit)
             ops.each_with_index do |op, idx|
               y = first_y + ((idx + offset) * line_h)
               text_blocks << build_text(bounds.x + VISIBILITY_X_OFFSET, y,
                                         visibility_prefix(op), family, size, size_unit, logical_height: logical_height)
               text = operation_text(op, parameter_detail: parameter_detail)
-              text_blocks << build_text(bounds.x + AttributeRenderer.content_x_offset(size), y,
+              text_blocks << build_text(bounds.x + content_x_offset, y,
                                         text, family, size, size_unit, logical_height: logical_height)
             end
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
@@ -102,6 +105,15 @@ module Ea
           end
           private_class_method :reception_params
 
+          def self.reception_heading_width(family, size, size_unit, logical_height)
+            TextRenderer.estimate_width(
+              "receptions", size,
+              family: family, weight: 400, style: "italic",
+              logical_height: size_unit == "pt" ? logical_height : nil
+            ).round
+          end
+          private_class_method :reception_heading_width
+
           def self.build_text(x, y, content, family, size, size_unit, logical_height: nil)
             TextRenderer.new(content: content, x: x, y: y,
                              family: family, size: size, size_unit: size_unit,

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
@@ -46,6 +45,21 @@ module Ea
                 family, size, size_unit, text_fill).to_svg
           end
 
+          def self.tab_height_for(stereotype:, family:, size:, size_unit: "pt")
+            rows = stereotype && !stereotype.empty? ? 2 : 1
+            nominal_height = rows == 2 ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+            line_height = if size_unit == "pt"
+                            Ea::Fonts::Metrics.compartment_line_height(
+                              size, family: family, unit: size_unit, offset: TAB_TEXT_PADDING
+                            )
+                          else
+                            TAB_LABEL_Y_OFFSET
+                          end
+            # Preserve the nominal padding while each row follows the same
+            # font line height used to place the package header text.
+            nominal_height + rows * (line_height - TAB_LABEL_Y_OFFSET)
+          end
+
           def initialize(bounds, fill, stroke, stroke_width, label,
                          stereotype, family, size, size_unit, text_fill)
             @bounds = bounds
@@ -148,7 +162,8 @@ module Ea
           end
 
           def tab_height
-            has_stereotype? ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+            self.class.tab_height_for(stereotype: stereotype, family: family,
+                                      size: size, size_unit: size_unit)
           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.123"
 end

metadata

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