ea 0.6.128 → 0.6.130

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

@@ -80,9 +80,9 @@ module Ea
             target_multiplicity_raw: raw_card(row.destcard),
             source_aggregation: source_aggregation_for(row),
             target_aggregation: aggregation_from(row.destisaggregate),
-            source_navigable: navigable?(row.sourceaccess, row.direction,
+            source_navigable: navigable?(row.sourceisnavigable, row.direction,
                                          :source),
-            target_navigable: navigable?(row.destaccess, row.direction, :target)
+            target_navigable: navigable?(row.destisnavigable, row.direction, :target)
           }
         end
 
@@ -148,10 +148,10 @@ module Ea
           ConnectorRelationshipMap.source_aggregation_for(row.connector_type)
         end
 
-        def navigable?(_access, direction, end_label)
-          # EA's navigability is messy. Treat unspecified direction
-          # as bidirectional, "Source -> Destination" as target-only
-          # navigable, etc. Conservative default: both ends navigable.
+        def navigable?(flag, direction, end_label)
+          return flag == 1 if [0, 1].include?(flag)
+
+          # Missing or unspecified flags retain the direction fallback.
           case direction.to_s
           when "<->", "" then true
           when "->" then end_label == :target

data/lib/ea/sources/xmi/relationship_builder.rb

@@ -76,8 +76,8 @@ module Ea
             target_multiplicity_upper: parse_upper(target_end),
             source_aggregation: source_end&.aggregation || "none",
             target_aggregation: target_end&.aggregation || "none",
-            source_navigable: navigable?(source_end),
-            target_navigable: navigable?(target_end)
+            source_navigable: navigable?(element, :source),
+            target_navigable: navigable?(element, :target)
           }
         end
 
@@ -128,13 +128,20 @@ module Ea
           Integer(raw) rescue 1
         end
 
-        def navigable?(end_element)
-          return true unless end_element
+        def connector_index
+          @connector_index ||= begin
+            connectors = root.extension&.connectors&.connector || []
+            connectors.each_with_object({}) do |connector, index|
+              index[connector.idref] = connector if connector.idref
+            end
+          end
+        end
 
-          # XMI represents non-navigable ends with aggregation=none
-          # and no role name; treat presence of role name or any
-          # aggregation as navigable. Default: navigable.
-          true
+        def navigable?(element, endpoint)
+          connector = connector_index[element.id]
+          end_element = connector&.public_send(endpoint)
+          flag = end_element&.modifiers&.is_navigable
+          flag.nil? || flag
         end
       end
     end

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

@@ -8,6 +8,11 @@ module Ea
         # Renders only when the host element is a Note with a
         # non-empty body.
         module NoteBody
+          # Native notes put the first baseline this far below the note
+          # top plus the font's GDI cell ascent (Arial 9pt/10pt +27,
+          # Cambria 7pt +24, Carlito 9pt +26).
+          TEXT_TOP = 14
+
           module_function
 
           def render(context)
@@ -22,17 +27,15 @@ module Ea
           end
 
           def wrapped_lines(context, body)
-            # Lines fit bounds.width - 4. Pitch and
-            # first-line offset scale with the note font (9pt: pitch
-            # 16 = size+7, first line at bounds.y + 18 = size+9), and
-            # each paragraph break adds one blank pitch row
-            # (paragraph 2 starts 32 after the last line of
-            # paragraph 1).
+            # Lines fit bounds.width - 4. Pitch is the GDI cell height
+            # of the note font and the first baseline sits TEXT_TOP
+            # plus the cell ascent below the top; fonts without
+            # vertical data keep pitch size+7 and offset size+9. Each
+            # empty source line adds one blank pitch row.
             usable = context.bounds.width - 4
             size = context.size
             family = context.family
-            pitch = size + 7
-            first_offset = size + 9
+            pitch, first_offset = vertical_layout(context)
             y_index = 0
             paragraphs = NoteHtml.paragraphs(body)
             paragraphs.flat_map do |para|
@@ -52,28 +55,38 @@ module Ea
                   width_factor: context.theme.text_width_factor
                 ).to_svg
               end
-              y_index += lines.size + (para.tight ? 0 : 1)
+              y_index += lines.size + para.gap
               paragraph_svg
             end
           end
 
-          # Wrap at whitespace until native script-specific break metrics are
-          # established. Every word but the paragraph's last carries its
-          # trailing space into the fit test.
+          # [pitch, first-baseline offset] for the note font.
+          def vertical_layout(context)
+            size = context.size
+            height = context.logical_height
+            height ||= Ea::Fonts::Metrics.gdi_logical_height(size) if context.size_unit == "pt"
+            ascent, descent = Ea::Fonts::Metrics.gdi_cell_metrics(context.family, height)
+            return [size + 7, size + 9] unless ascent
+
+            [ascent + descent, TEXT_TOP + ascent]
+          end
+          module_function :vertical_layout
+
+          # Break at whitespace and between a CJK character and its
+          # neighbours. Every atom but the paragraph's last carries a
+          # following space, when the source has one, into the fit test.
           def wrap_paragraph(para, usable, size, family, logical_height: nil)
             lines = []
             current = ""
-            words = para.strip.split(/\s+/)
-            words.each_with_index do |word, index|
-              candidate = current.empty? ? word : "#{current} #{word}"
-              trailing = index < words.size - 1 ? " " : ""
-              width = TextRenderer.estimate_width("#{candidate}#{trailing}", size, nil,
-                                                  family: family, logical_height: logical_height).round
-              if current.empty? || width <= usable
+            atoms = break_atoms(para)
+            atoms.each_with_index do |atom, index|
+              candidate = current.empty? ? atom[:text] : "#{current}#{atom[:space]}#{atom[:text]}"
+              measured = "#{candidate}#{atoms.dig(index + 1, :space)}"
+              if current.empty? || fit_width(measured, size, family, logical_height) <= usable
                 current = candidate
               else
                 lines << current
-                current = word
+                current = atom[:text]
               end
             end
             lines << current unless current.empty?
@@ -81,6 +94,29 @@ module Ea
           end
           module_function :wrap_paragraph
 
+          def fit_width(text, size, family, logical_height)
+            TextRenderer.estimate_width(text, size, nil, family: family, logical_height: logical_height).round
+          end
+          module_function :fit_width
+
+          # Unbreakable runs of text with the space that precedes each one.
+          def break_atoms(text)
+            words = text.split(/\s+/).reject(&:empty?)
+            words.each_with_index.flat_map { |word, index| word_atoms(word, index.positive? ? " " : "") }
+          end
+          module_function :break_atoms
+
+          def word_atoms(word, space)
+            runs = word.chars.slice_when { |a, b| cjk_char?(a) || cjk_char?(b) }.map(&:join)
+            runs.each_with_index.map { |run, i| { text: run, space: i.zero? ? space : "" } }
+          end
+          module_function :word_atoms
+
+          def cjk_char?(char)
+            Ea::Fonts::Metrics.cjk?(char.ord)
+          end
+          module_function :cjk_char?
+
           def group_style(context)
             "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
               "fill:#{context.theme.text_color};fill-opacity:1.00; " \

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

@@ -4,13 +4,14 @@ module Ea
   module Svg
     module EaEmitter
       module Compartment
-        # Splits a note body into paragraphs. A body with HTML markup is
-        # shown by EA as plain text: tags are dropped, entities decoded,
-        # `<ul>`/`</ul>` lines take no row, and each `<li>` becomes a
-        # "- " line stacked directly under the previous text or item
-        # (`tight`) instead of leaving the blank row between paragraphs.
+        # Splits a note body into paragraphs, one per non-empty source
+        # line. Each paragraph stacks directly under the previous one
+        # (`gap` 0); every empty source line after it adds one blank row.
+        # A body with HTML markup is shown by EA as plain text: tags are
+        # dropped, entities decoded, `<ul>`/`</ul>` lines take no row,
+        # each `<li>` becomes a "- " line and `<br>` ends a line.
         module NoteHtml
-          Paragraph = Struct.new(:text, :tight)
+          Paragraph = Struct.new(:text, :gap)
 
           TAG = %r{</?(?:ul|ol|li|b|i|u|p|br|strong|em)\b[^>]*>}i
           LINE_BREAK = /<br\b[^>]*>/i
@@ -22,37 +23,23 @@ module Ea
 
           def paragraphs(body)
             text = body.to_s
-            return plain(text) unless text.match?(TAG)
-
-            entries = html_lines(text)
-            entries.each_with_index.map do |(line, _item, broken), index|
-              Paragraph.new(line, broken || entries[index + 1]&.at(1) || false)
+            markup = text.match?(TAG)
+            lines = text.split(/\r?\n/)
+            lines.reject! { |raw| raw.strip.match?(LIST_WRAPPER) } if markup
+            lines.each_with_object([]) do |raw, paragraphs|
+              raw.strip.empty? ? paragraphs.last&.gap += 1 : paragraphs.concat(line_paragraphs(raw, markup))
             end
           end
 
-          def plain(text)
-            text.split(/\n/).reject { |line| line.strip.empty? }.map { |line| Paragraph.new(line, false) }
-          end
-
-          def html_lines(text)
-            text.split(/\r?\n/).flat_map do |raw|
-              line = raw.strip
-              next [] if line.empty? || line.match?(LIST_WRAPPER)
-
-              item = line.match(LIST_ITEM)
-              item ? broken_lines(item[1], "- ") : broken_lines(line, "")
-            end
+          def line_paragraphs(raw, markup)
+            markup ? html_lines(raw.strip) : [Paragraph.new(raw, 0)]
           end
 
-          # Entries are [text, starts_item, broken]. `<br>` ends a line
-          # without the blank row a new paragraph gets, so every segment
-          # but the last is `broken` (tight). Only the first segment
-          # carries the list bullet.
-          def broken_lines(line, bullet)
-            segments = line.split(LINE_BREAK).map { |segment| clean(segment) }.reject(&:empty?)
+          def html_lines(line)
+            item = line.match(LIST_ITEM)
+            segments = (item ? item[1] : line).split(LINE_BREAK).map { |segment| clean(segment) }.reject(&:empty?)
             segments.each_with_index.map do |segment, index|
-              first = index.zero?
-              [first ? "#{bullet}#{segment}" : segment, first && !bullet.empty?, index < segments.size - 1]
+              Paragraph.new(item && index.zero? ? "- #{segment}" : segment, 0)
             end
           end
 

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

@@ -19,6 +19,10 @@ module Ea
         # self-loop, or no drawn bounds for either end).
         def pairs_for(connector, diagram, model_index, bounds_map)
           return nil unless bounds_map
+
+          tether = association_class_pairs(connector, bounds_map)
+          return tether if tether
+
           points = waypoint_pairs(connector)
           lateral = lateral_tree?(connector, points)
           trunk = trunk_tree?(connector, points)
@@ -74,6 +78,42 @@ module Ea
           auto_port_elbow_pairs(connector, source, target, pairs)
         end
 
+        # A tether joins its saved association anchor to the facing
+        # side-center of the attached class, rather than to the other proxy.
+        def association_class_pairs(connector, bounds_map)
+          bounds = bounds_map[connector.style.to_h[:association_class_ref]]
+          anchor = connector.source_anchor
+          return nil unless bounds && anchor
+
+          [[anchor.x, anchor.y], association_class_dock(bounds, anchor)]
+        end
+        private_class_method :association_class_pairs
+
+        def association_class_dock(bounds, anchor)
+          center = association_class_center(bounds)
+          if horizontal_association_class?(bounds, anchor, center)
+            [association_class_edge_coordinate(bounds.x, bounds.width, anchor.x), center[1]]
+          else
+            [center[0], association_class_edge_coordinate(bounds.y, bounds.height, anchor.y)]
+          end
+        end
+        private_class_method :association_class_dock
+
+        def association_class_center(bounds)
+          [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2]
+        end
+        private_class_method :association_class_center
+
+        def horizontal_association_class?(bounds, anchor, center)
+          (anchor.x - center[0]).abs * bounds.height > (anchor.y - center[1]).abs * bounds.width
+        end
+        private_class_method :horizontal_association_class?
+
+        def association_class_edge_coordinate(origin, size, anchor)
+          anchor > origin + size / 2 ? origin + size : origin
+        end
+        private_class_method :association_class_edge_coordinate
+
         # Auto routing turns at the clipped target column when the source
         # leaves a side edge and the target enters through its top or bottom.
         def auto_port_elbow_pairs(connector, source, target, pairs)

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

@@ -91,6 +91,7 @@ module Ea
         end
 
         def dashed?(connector)
+          return true if connector.style.to_h[:association_class_ref]
           return true if connector.connector_type == "Dependency"
           return false unless connector.connector_type == "Package"
 

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

@@ -17,6 +17,11 @@ module Ea
       # text-emitting layer.
       class FontResolver
         DEFAULT_FONT_FAMILY = "Yu Gothic UI"
+        # EA draws every text kind of a hand-drawn diagram (names, notes,
+        # connector labels) in this family.
+        HAND_DRAW_FAMILY = "Source Sans Pro"
+        # Native hand-drawn connector end labels carry font-weight:0.
+        HAND_DRAW_LABEL_WEIGHT = 0
         # EA's default element compartment font size. EA-published
         # reference SVGs render body text at 7pt (the current EA
         # theme size) for every element whose objectstyle fontsz is
@@ -87,7 +92,7 @@ module Ea
         private
 
         def default_family_for(explicit)
-          return "Source Sans Pro" if diagram.hand_draw
+          return HAND_DRAW_FAMILY if diagram.hand_draw
 
           theme_family_for(explicit) || diagram_default_family || DEFAULT_FONT_FAMILY
         end

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

@@ -28,10 +28,12 @@ module Ea
           MIN_ROLE_X = 3
 
           attr_reader :canvas, :model_index, :document, :theme,
-                      :font_family, :font_size, :font_unit
+                      :font_family, :font_size, :font_unit,
+                      :font_weight, :font_style
 
           def initialize(canvas:, model_index:, document:, theme:,
-                         font_family:, font_size:, font_unit:)
+                         font_family:, font_size:, font_unit:,
+                         font_weight: 400, font_style: "normal")
             @canvas = canvas
             @model_index = model_index
             @document = document
@@ -39,6 +41,8 @@ module Ea
             @font_family = font_family
             @font_size = font_size
             @font_unit = font_unit
+            @font_weight = font_weight
+            @font_style = font_style
           end
 
           # Returns an Array of `<text>` SVG strings for one endpoint.
@@ -49,12 +53,13 @@ module Ea
           #   connector  - the DiagramConnector (for relationship lookup)
           #   end_kind   - :source or :target
           #   heading    - [dx, dy] of the first leg leaving the anchor
+          #   source_bounds - effective drawn source outline, in anchor coordinates
           #   bend       - first bend of a saved descending vertical stair
           #   stored_labels - the connector has stored label boxes at
           #                   either end; false keeps the opposite-end
           #                   fallback
           def texts(text_box:, mult_box:, anchor:, connector:, end_kind:,
-                    tree: false, heading: nil, stored_labels: false, bend: nil)
+                    tree: false, heading: nil, stored_labels: false, bend: nil, source_bounds: nil)
             from_property, role, mult = role_and_multiplicity(connector, end_kind)
             if role_empty?(role) && mult_empty?(mult)
               other_from_prop, other_role, other_mult = role_and_multiplicity(connector,
@@ -105,6 +110,7 @@ module Ea
               text_pos = plain_leftward_target_role(connector, heading, anchor, text_box, role) ||
                          target_leftward_property_role(connector, heading, anchor, text_box, role) ||
                          target_property_role(connector, heading, anchor, text_box, role) ||
+                         saved_ray_target_property_role(connector, heading, anchor, text_box, role) ||
                          target_diagonal_property_role(connector, heading, anchor, text_box, role) ||
                          target_vertical_role(connector, heading, anchor, text_box, role) ||
                          target_rightward_role(heading, anchor, text_box, role) || text_pos
@@ -115,6 +121,9 @@ module Ea
             if end_kind == :source
               text_pos = source_top_property_role(connector, heading, anchor, text_box, role) ||
                          source_bottom_property_role(connector, heading, anchor, text_box, role) || text_pos
+              if external_upward_property_source?(connector, heading, anchor, text_box, source_bounds)
+                text_pos = external_upward_property_role(anchor, role) || text_pos
+              end
             end
 
             text_box = text_box.merge("alignment" => 1) if phantom_property_box?(connector, direction, text_box)
@@ -138,12 +147,48 @@ module Ea
             return nil unless heading && heading[0].negative? && heading[1].zero?
             return nil unless plain_target_role?(connector, box, role)
 
+            return saved_ray_plain_target_position(anchor, box, role) if moved_plain_target_ray?(connector, box)
+
             PlainTargetSeat.position(
               connector: connector, anchor: anchor, box: box,
               width: Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
             )
           end
 
+          def saved_ray_plain_target_position(anchor, box, role)
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            x, y = seat_corner(anchor, box)
+            [x - width - SEAT_X_INSET, y - 7] if width
+          end
+
+          def moved_plain_target_ray?(connector, box)
+            saved_target_ray?(connector) && box.values_at("alignment", "cy") == [1, 16] &&
+              !stored_offsets_zero?(box)
+          end
+
+          def saved_target_ray?(connector)
+            connector.connector_type == "Association" &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree, :stored_association_ray) == ["3", "0", nil, true]
+          end
+
+          # Moved Property boxes on saved rays arriving from below use the
+          # downward seat, relative to the persisted label corner.
+          def saved_ray_target_property_role(connector, heading, anchor, box, role)
+            return nil unless downward_saved_property?(connector, heading, box)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            inset, baseline = property_role_offsets(:down)
+            [x - inset - width, y + baseline]
+          end
+
+          def downward_saved_property?(connector, heading, box)
+            heading && heading[1].positive? && heading[1] > heading[0].abs &&
+              saved_target_ray?(connector) && moved_target_property_box?(connector, box)
+          end
+
           def plain_target_role?(connector, box, role)
             seat_font? && cambria_box?(box) && !role_empty?(role) &&
               connector_source_dest_stereotype(connector, :target).to_s.empty?
@@ -302,6 +347,43 @@ module Ea
             source_property_seat(connector, :up, anchor, box, role)
           end
 
+          # A persisted origin above the drawn source outline keeps the
+          # upward seat's inset and the shared upper baseline, including
+          # steep diagonals. Origins clipped onto the face retain -6.
+          def external_upward_property_role(anchor, role)
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            inset, = property_role_offsets(:up)
+            _, baseline = property_role_offsets(:left)
+            [[anchor[0] - inset - width, MIN_ROLE_X].max, anchor[1] + baseline]
+          end
+
+          def external_upward_property_source?(connector, heading, anchor, box, bounds)
+            upward_source_heading?(heading) &&
+              zero_source_property_box?(box) && cambria_box?(box) && source_property_cambria?(connector) &&
+              external_source_route?(connector, anchor) && above_source_outline?(anchor, bounds)
+          end
+
+          def upward_source_heading?(heading)
+            source_seat?(:source, heading) && heading[1].negative? && heading[1].abs > heading[0].abs
+          end
+
+          def external_source_route?(connector, anchor)
+            origin = connector.source_anchor
+            connector.connector_type == "Association" && connector.waypoints.size == 3 &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] &&
+              connector.label_boxes.to_h.values_at(:llt, :llb).all?(&:nil?) &&
+              origin && [origin.x, origin.y] == anchor
+          end
+
+          def above_source_outline?(anchor, bounds)
+            return false unless bounds&.width&.positive? && bounds.height.positive?
+
+            anchor[1] < bounds.y &&
+              anchor[0].between?(bounds.x, bounds.x + bounds.width)
+          end
+
           def zero_source_property_box?(box)
             box && box["alignment"]&.zero? && stored_offsets_zero?(box)
           end
@@ -371,7 +453,8 @@ module Ea
           end
 
           def horizontal_target_property_route?(style)
-            style.values_at(:mode, :lwidth) == %w[3 2] && [nil, "LH"].include?(style[:tree])
+            style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] ||
+              (style.values_at(:mode, :lwidth) == %w[3 2] && [nil, "LH"].include?(style[:tree]))
           end
 
           # An upward target uses the downward property's right edge and
@@ -453,9 +536,8 @@ module Ea
             seat_font? && cambria_box?(box) && [0, 1].include?(box["alignment"])
           end
 
-          # A target leg that runs down seats only on the "LV" tree route
-          # with line width 2; every other vertical seat needs the plain
-          # width-0 route.
+          # Downward target seats require LV width 2; upward target seats
+          # also accept LV width 0. Source seats require a plain width-0 route.
           def plain_vertical_connector?(connector, end_kind, direction)
             return false unless connector.connector_type == "Association" &&
                                 connector_source_dest_stereotype(connector, end_kind).empty?
@@ -468,6 +550,8 @@ module Ea
 
             if direction == :target_down
               style[:lwidth] == "2" && style[:tree] == "LV"
+            elsif direction == :target_up
+              style[:lwidth] == "0" && [nil, "LV"].include?(style[:tree])
             else
               style[:lwidth] == "0" && !style[:tree]
             end
@@ -915,6 +999,7 @@ module Ea
             y_t = canvas ? canvas.translate_y(y) : y
             TextRenderer.new(content:, x: x_t, y: y_t,
                              family: font_family, size: font_size,
+                             weight: font_weight, style: font_style,
                              size_unit: font_unit,
                              fill: fill_color).to_svg
           end

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

@@ -15,15 +15,17 @@ module Ea
         # Stereotype wins when both are present.
         class MidpointLabel
           attr_reader :canvas, :model_index, :font_family, :font_size,
-                      :font_unit
+                      :font_unit, :font_weight, :font_style
 
           def initialize(canvas:, model_index:, font_family:, font_size:,
-                         font_unit:)
+                         font_unit:, font_weight: 400, font_style: "normal")
             @canvas = canvas
             @model_index = model_index
             @font_family = font_family
             @font_size = font_size
             @font_unit = font_unit
+            @font_weight = font_weight
+            @font_style = font_style
           end
 
           # Returns the SVG `<text>` for the connector's midpoint
@@ -112,14 +114,15 @@ module Ea
             return nil unless stereotype_label(connector)
 
             box = connector.label_boxes.to_h[:lmb]
-            return nil unless default_name_box?(box)
+            return nil unless default_name_box?(box, alignments: [0, 1])
 
             stored_position(connector, points, box, LINE_PITCH)
           end
 
           # At 7pt, a centered name's stored corner is 3px below its baseline.
           def stored_name_position(connector, points)
-            stored_position(connector, points, stored_name_box(connector), -3)
+            seat_points = horizontal_bend_seat(points) || points
+            stored_position(connector, seat_points, stored_name_box(connector, points), -3)
           end
 
           def stored_position(connector, points, box, baseline)
@@ -133,21 +136,37 @@ module Ea
             [x + offset_x - (width / 2.0).floor, y + offset_y + baseline]
           end
 
-          def stored_name_box(connector)
+          def stored_name_box(connector, points)
             return nil unless connector.is_a?(Ea::Model::DiagramConnector) && measured_name_font?
             return nil if connector.is_substitutable || stereotype_label(connector)
             return nil if midpoint_content(connector).include?(": ")
 
             box = connector.label_boxes.to_h[:lmt]
-            box if default_name_box?(box)
+            alignments = name_box_alignments(points)
+            box if default_name_box?(box, alignments: alignments)
+          end
+
+          def name_box_alignments(points)
+            horizontal_bend_seat(points) ? [0, 1] : [1]
+          end
+
+          # A vertical-to-horizontal bend seats its name on the horizontal leg.
+          def horizontal_bend_seat(points)
+            return nil unless points.size == 3
+
+            source, bend, target = points
+            return nil unless source[0] == bend[0] && source[1] != bend[1] &&
+                              bend[1] == target[1] && bend[0] != target[0]
+
+            [bend, target]
           end
 
           def measured_name_font?
             font_family.to_s.casecmp("Cambria").zero? && font_size == 7 && font_unit == "pt"
           end
 
-          def default_name_box?(box)
-            return false unless box && box["alignment"] == 1
+          def default_name_box?(box, alignments: [1])
+            return false unless box && alignments.include?(box["alignment"])
             return false unless box.values_at("ox", "oy").all?
             return false unless [nil, 0, 1].include?(box["direction"]) && [nil, -1].include?(box["color"])
 
@@ -191,6 +210,7 @@ module Ea
             y_t = canvas ? canvas.translate_y(y) : y
             TextRenderer.new(content:, x: x_t, y: y_t,
                              family: font_family, size: font_size,
+                             weight: font_weight, style: font_style,
                              size_unit: font_unit,
                              fill: "#000000").to_svg
           end