ea 0.6.106 → 0.6.108

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

@@ -115,9 +115,11 @@ module Ea
                       else
                         stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
                       end
-            return model unless allowed
+            return model unless allowed && stored_association_path?(model, link_row, source, target, geom)
 
             set_stored_ray_origins(model, source, target, geom)
+            model.style[:association_ray_outline] = true if model.connector_type == "Association"
+            model
           end
 
           # An empty-Path Mode 3 Association follows the line between its
@@ -125,6 +127,7 @@ module Ea
           # The target origin must lie inside its own stroked outline.
           def association_stored_ray(model, link_row, diagram_row, geom, context)
             return model if context
+            return stored_diagonal_corner(model, link_row, diagram_row, geom) unless link_row.path.to_s.empty?
             return model unless association_ray_candidate?(model, link_row)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
@@ -141,6 +144,47 @@ module Ea
             model
           end
 
+          # A single authored bend joins the stored mathematical origins.
+          # Clip each leg independently; a facing-edge shortcut loses the bend.
+          def stored_diagonal_corner(model, link_row, diagram_row, geom)
+            return model unless model.connector_type == "Association" && association_ray_style?(model.style.to_h) &&
+                                model.style[:lwidth] == "2" && geom.values_at(:sx, :sy, :ex, :ey).all?
+
+            corners = intermediate_waypoints(link_row)
+            return model unless corners.size == 1
+
+            boxes = stored_ray_boxes(link_row, diagram_row)
+            origins = [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]),
+                       stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
+            bend = Ea::Model::Point.new(x: corners[0][0], y: corners[0][1])
+            left, right = boxes.sort_by(&:x)
+            return model unless bend.x.between?(left.x + left.width + 1, right.x - 1) &&
+                                boxes.all? { |box| bend.y.between?(box.y, box.y + box.height) }
+
+            outlines = boxes.map { |box| grown_bounds(box, 1) }
+            return model unless origins.zip(outlines).all? { |origin, box| inside_box?(origin, box) }
+            return model if outlines.any? { |box| inside_box?(bend, box) }
+            return model unless origins.all? { |origin| origin.x != bend.x && origin.y != bend.y }
+
+            ends = origins.zip(outlines).map { |origin, box| diagonal_corner_exit(origin, bend, box) }
+            return model unless ends.all?
+
+            model.waypoints = [ends[0], bend, ends[1]].map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.source_anchor, model.target_anchor = origins
+            model
+          end
+
+          def diagonal_corner_exit(origin, bend, box)
+            dx = bend.x - origin.x
+            dy = bend.y - origin.y
+            times = [(dx.positive? ? box.x + box.width - origin.x : box.x - origin.x).to_f / dx,
+                     (dy.positive? ? box.y + box.height - origin.y : box.y - origin.y).to_f / dy]
+            time = times.select { |value| value.between?(0, 1) }.min
+            return unless time
+
+            Ea::Model::Point.new(x: (origin.x + time * dx).floor, y: (origin.y + time * dy).floor)
+          end
+
           def port_waypoints(model, origins)
             [model.source_port || origins.first, model.target_port || origins.last].map do |point|
               Ea::Model::Waypoint.new(position: point)
@@ -198,7 +242,15 @@ module Ea
           def association_ray_candidate?(model, link_row)
             model.connector_type == "Association" && link_row.path.to_s.empty? &&
               model.source_anchor && model.target_anchor &&
-              (model.source_port || model.target_port) && association_ray_style?(model.style.to_h)
+              (model.source_port || model.target_port || aligned_default_origins?(model)) &&
+              association_ray_style?(model.style.to_h)
+          end
+
+          # Zero offsets omit ports, but an explicitly stored axis-aligned
+          # width-2 ray still uses the logical centers and stroked outlines.
+          def aligned_default_origins?(model)
+            model.has_geometry_offsets && model.style[:lwidth] == "2" &&
+              (model.source_anchor.x == model.target_anchor.x || model.source_anchor.y == model.target_anchor.y)
           end
 
           # A thin connector still meets the outer stroke of explicitly
@@ -238,73 +290,6 @@ module Ea
               point.y.between?(bounds.y, bounds.y + bounds.height)
           end
 
-          # A Mode 2 Association with equal SX/EX (vertical EDGE 1/3) or
-          # equal SY/EY (horizontal EDGE 4) and no custom Path docks as a
-          # straight line through the middle of the boxes' overlap, moved
-          # by the shared stored offset. Stored SY counts upward.
-          def overlap_ray_origins(model, link_row, diagram_row, geom, context)
-            return model if context
-            return model unless overlap_ray_candidate?(model, link_row, geom)
-
-            source, target = stored_ray_boxes(link_row, diagram_row)
-            origins = overlap_origins(source, target, geom)
-            return model unless origins
-
-            model.source_anchor, model.target_anchor = origins.map do |ox, oy|
-              Ea::Model::Point.new(x: ox, y: oy)
-            end
-            model.style[:overlap_ray] = true
-            model
-          end
-
-          # Both ray origins share the overlap coordinate on the axis the
-          # offsets move and sit at each box's centre on the other axis.
-          def overlap_origins(source, target, geom)
-            along, across, offset = overlap_axes(geom)
-            coordinate = overlap_ray_coordinate(*box_span(source, along), *box_span(target, along), offset)
-            return nil unless coordinate && disjoint_span?(*box_span(source, across), *box_span(target, across))
-
-            [source, target].map do |box|
-              start, size = box_span(box, across)
-              centre = start + size / 2.0
-              geom[:edge] == 4 ? [centre, coordinate] : [coordinate, centre]
-            end
-          end
-
-          # [axis the offsets move, axis the boxes face, stored offset]
-          def overlap_axes(geom)
-            return [%i[y height], %i[x width], -geom[:sy]] if geom[:edge] == 4
-
-            [%i[x width], %i[y height], geom[:sx]]
-          end
-
-          def box_span(box, keys)
-            keys.map { |key| box.public_send(key) }
-          end
-
-          def overlap_ray_candidate?(model, link_row, geom)
-            model.connector_type == "Association" && model.style[:mode] == "2" &&
-              model.waypoints.size == 2 && link_row.path.to_s.empty? &&
-              model.has_geometry_offsets && uniform_overlap_offsets?(geom)
-          end
-
-          def uniform_overlap_offsets?(geom)
-            return false unless geom.values_at(:sx, :sy, :ex, :ey).all?
-
-            geom[:edge] == 4 ? geom[:sy] == geom[:ey] : [1, 3].include?(geom[:edge]) && geom[:sx] == geom[:ex]
-          end
-
-          # Floor of the overlap midpoint plus the shared offset; nil
-          # when the boxes do not overlap on this axis.
-          def overlap_ray_coordinate(start_a, size_a, start_b, size_b, offset)
-            low = [start_a, start_b].max
-            high = [start_a + size_a, start_b + size_b].min
-            return nil if low > high
-
-            coordinate = ((low + high) / 2.0 + offset).floor
-            coordinate if coordinate.between?(low, high)
-          end
-
           def disjoint_span?(start_a, size_a, start_b, size_b)
             start_a + size_a < start_b || start_b + size_b < start_a
           end
@@ -322,11 +307,17 @@ module Ea
           end
 
           def stored_ray_candidate?(model, link_row, geom)
-            %w[Generalization Aggregation].include?(model.connector_type) &&
+            stored_ray_type?(model) &&
               model.waypoints.size == 2 && stored_ray_style?(model.style, link_row) &&
               stored_ray_geometry?(model, geom)
           end
 
+          def stored_ray_type?(model)
+            %w[Generalization Aggregation].include?(model.connector_type) ||
+              (model.connector_type == "Association" && model.style[:mode] == "1" &&
+                model.style[:lwidth] == "2")
+          end
+
           # Boundary-port rounding can move a computed jog off a level saved
           # ray. Equal stored origin rows specify the line before clipping.
           def normalized_level_ray?(model, source, target, geom)
@@ -408,6 +399,7 @@ module Ea
             when "Association"
               return unless style[:lwidth] == "0"
 
+              redock_child_below(points, bounds_from_rect(source_placement), bounds_from_rect(target_placement))
               redock_parent_above(points, link_row, source_placement, target_placement, strict: true)
             end
           end
@@ -517,15 +509,18 @@ module Ea
               [bounds.y, bounds.y + bounds.height].include?(point[1])
           end
 
-          # A width-2 Mode 3 Aggregation without a tree style keeps an authored
-          # orthogonal stair-step of three or more corners. Each end docks on
+          # A width-2 Mode 3 route without a tree style keeps authored orthogonal
+          # bends: two corners for Associations, three or more for Aggregations.
+          # Each end docks on
           # the 1px outline its adjacent leg points at, from the corner's own
           # coordinate; any end that cannot do so leaves the route unchanged.
           def stored_stair_route(link_row, connector, source, target)
             return nil unless stair_style?(link_row, connector)
 
             corners = stored_square_corners(link_row)
-            return nil unless corners && corners.size >= 3 && alternating_legs?(corners)
+            unless corners && stair_corner_count?(corners, connector.connector_type) && alternating_legs?(corners)
+              return nil
+            end
 
             first = outline_dock(corners[0], corners[1], source)
             last = outline_dock(corners[-1], corners[-2], target)
@@ -534,10 +529,14 @@ module Ea
 
           def stair_style?(link_row, connector)
             style = DiagramStyleParser.parse(link_row.style)
-            connector.connector_type == "Aggregation" && style[:mode] == "3" &&
+            %w[Aggregation Association].include?(connector.connector_type) && style[:mode] == "3" &&
               style[:lwidth] == "2" && !style.key?(:tree)
           end
 
+          def stair_corner_count?(corners, connector_type)
+            connector_type == "Association" ? corners.size == 2 : corners.size >= 3
+          end
+
           # Every leg is non-zero and runs along the opposite axis of the last.
           def alternating_legs?(corners)
             axes = corners.each_cons(2).map { |from, to| leg_axis(from, to) }
@@ -595,6 +594,8 @@ module Ea
           # flush on its box edge.
           def derived_lateral_route(link_row, connector, source, target)
             style = DiagramStyleParser.parse(link_row.style)
+            return derived_vertical_lateral_route(style, link_row, connector, source, target) if style[:tree] == "LV"
+
             return nil unless style[:mode] == "3" && style[:tree] == "LH" &&
                               derived_lateral_path?(connector.connector_type, link_row.path.to_s)
 
@@ -726,7 +727,7 @@ module Ea
           # Keep a vertical tree trunk whose bends still fit both boxes
           # and the open gap; the closest facing edges need not share its x.
           def preserve_stored_tree?(points, link_row, connector, src, tgt)
-            return false unless points.size == 4 && stored_tree_type?(points, link_row, connector)
+            return false unless points.size == 4 && stored_tree_type?(points, link_row, connector, src, tgt)
 
             style = DiagramStyleParser.parse(link_row.style)
             return false unless style[:lwidth] == "2" || flush_width_zero_tree?(link_row)
@@ -897,14 +898,13 @@ module Ea
             style[:tree] == "V" || (style[:mode] == "3" && style[:tree].nil?)
           end
 
-          def stored_tree_type?(points, link_row, connector)
-            connector.connector_type == "Aggregation" || flush_straight_association?(points, link_row, connector)
-          end
+          def stored_tree_type?(points, link_row, connector, source, target)
+            return true if connector.connector_type == "Aggregation"
+            return false unless connector.connector_type == "Association" && flush_width_zero_tree?(link_row)
 
-          # A flush Association keeps only a straight trunk (one bend stored twice).
-          def flush_straight_association?(points, link_row, connector)
-            connector.connector_type == "Association" && points[1] == points[-2] &&
-              flush_width_zero_tree?(link_row)
+            # Distinct thin bends are supported when the source sits above
+            # the target; the established reverse case keeps straight trunks.
+            points[1] == points[-2] || source.y + source.height < target.y
           end
 
           # A flush trunk may also hang below its parent; a bend repeated at

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

@@ -13,11 +13,13 @@ module Ea
         autoload :Routing, "ea/sources/qea/diagram_builder/routing"
         autoload :AutoRouting, "ea/sources/qea/diagram_builder/auto_routing"
         autoload :StoredSquarePorts, "ea/sources/qea/diagram_builder/stored_square_ports"
+        autoload :FontSettings, "ea/sources/qea/diagram_builder/font_settings"
         include Routing
         include AutoRouting
         include StoredSquarePorts
+        include FontSettings
         private_constant :Routing
-        private_constant :AutoRouting, :StoredSquarePorts
+        private_constant :AutoRouting, :StoredSquarePorts, :FontSettings
 
         attr_reader :database
 
@@ -123,6 +125,8 @@ module Ea
         def build_element(obj_row, diagram_row)
           @current_obj_row = obj_row
           style_hash = DiagramStyleParser.parse(obj_row.objectstyle)
+          style_hash[:stored_attribute_order] = true
+          font_style = effective_font_style(obj_row, style_hash)
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic("de", diagram_row.diagram_id,
                                        obj_row.instance_id),
@@ -130,8 +134,10 @@ module Ea
             model_element_ref: ref_for_object(obj_row),
             bounds: bounds_from_rect(obj_row),
             style: style_hash,
-            font_family: presence(style_hash[:font]),
-            font_size: font_size_from(style_hash),
+            font_family: presence(font_style[:font]),
+            font_size: font_size_from(font_style),
+            font_size_unit: "pt",
+            font_logical_height: font_logical_height_from(font_style),
             font_bold: truthy?(style_hash[:bold]),
             font_italic: truthy?(style_hash[:italic]),
             font_underline: truthy?(style_hash[:ul]),
@@ -144,33 +150,6 @@ module Ea
           raw == "1" || raw == "-1"
         end
 
-        def presence(value)
-          value.nil? || value.to_s.empty? ? nil : value
-        end
-
-        # EA stores the element font size in tenths of a point and
-        # renders it through GDI's double rounding: pixel height =
-        # floor(tenths * 96 / 720), then point size =
-        # floor(pixels * 72 / 96). 70 -> 9px -> 6pt (F3660305 Text),
-        # 80 -> 10px -> 7pt, 90 -> 12px -> 9pt (4EBDE645's PI_*
-        # classes), 100 -> 13px -> 9pt (0D31AED1's all-100 elements
-        # publish 321 texts at 9pt), 120 -> 16px -> 12pt
-        # (412BC89E's Boundary title), 140 -> 18px -> 13pt.
-        # fontsz=0 ("use default", written back by the font dialog)
-        # renders at the 7pt theme size.
-        USE_DEFAULT_FONTSZ = [0].freeze
-        GDI_DPI = 96
-
-        def font_size_from(style_hash)
-          raw = style_hash[:fontsz]
-          return nil if raw.nil? || raw.to_s.empty?
-
-          return nil if USE_DEFAULT_FONTSZ.include?(raw.to_i)
-
-          pixels = (raw.to_f * GDI_DPI / 720).floor
-          (pixels * 72.0 / GDI_DPI).floor
-        end
-
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
           context = ContextDiagramSupport.context?(diagram_row)

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

@@ -34,6 +34,7 @@ module Ea
           Ea::Model::InstanceSpecification.new(
             id: IdNormalizer.from_guid(row.ea_guid),
             name: row.name.to_s,
+            role_name: row.alias,
             classifier_id: classifier_id_for(row),
             classifier_name: classifier_name_for(row),
             stereotype: row.stereotype.to_s,

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

@@ -16,7 +16,8 @@ module Ea
 
         def build_all_for(owner_object)
           attrs = database.attributes_for_object(owner_object.ea_object_id) || []
-          attrs.map { |row| build_one(row, owner_object) }
+          attrs.each_with_index.sort_by { |row, index| attribute_sort_key(row, index) }
+               .map { |row, _index| build_one(row, owner_object) }
         end
 
         def build_one(row, owner_object)
@@ -48,6 +49,15 @@ module Ea
 
         private
 
+        # Equal explicit Pos values use name order in EA's published diagrams.
+        # Missing positions retain source order before the explicit zero cohort.
+        def attribute_sort_key(row, index)
+          return [row.sort_position, 0, "", "", index] if row.pos.nil?
+
+          name = row.name.to_s
+          [row.sort_position, 1, name.downcase, name, index]
+        end
+
         # EA stores some bounds as literal text ("n"); those render
         # verbatim in attribute lines while computed-unbounded bounds
         # render as "*" (verified against EA-published SVGs).

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

@@ -7,11 +7,10 @@ module Ea
       #
       # Theme :119 applies:
       #   - Border color (#9A8484) for element strokes
-      #   - Attribute color (#66413F) for attribute text
       #   - Method color for operation text
       # Theme :119 does NOT apply:
       #   - Per-type fill colors (elements use default #FFFFFF)
-      #   - Text color (#000000 black for non-attribute text)
+      #   - Attribute text color (inherits the black text color)
       #
       # Precedence chain for fill:
       #   1. Element's BCol int (when present and not sentinel)

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

@@ -16,7 +16,8 @@ module Ea
               context.attr_lines,
               bounds: context.bounds,
               first_y: context.geometry.attr_first_y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.attribute_text_color,
               visibility_x_offset: context.theme.attribute_spec.visibility_x_offset,
               content_x_offset: context.theme.attribute_spec.content_x_offset

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

@@ -11,26 +11,17 @@ module Ea
         # content and suppresses them when they would overflow the
         # stored box height (never truncates rows).
         module Constraints
-          DEFAULT_TEXT_COLOR = "#000000"
-
           module_function
 
           def render(context)
             return nil unless context.constraints&.any?
-            return nil unless context.geometry.tagged_value_first_y
-
-            first_y = context.geometry.tagged_value_first_y
-            line_h = context.size + 6
-            last_y = first_y + (context.constraints.size - 1) * line_h
-            return nil if last_y + 4 > context.bounds.y + context.bounds.height
+            return nil unless context.geometry.constraints_first_y
 
-            Element::ConstraintRenderer.render(
-              context.constraints,
-              bounds: context.bounds,
-              first_y: first_y,
-              family: context.family, size: context.size,
-              fill: DEFAULT_TEXT_COLOR
+            divider = Element::DividerRenderer.render(
+              context.bounds, y: context.geometry.constraints_divider_y,
+                              stroke: context.stroke, stroke_width: context.stroke_width
             )
+            "#{divider}\n#{Element::ConstraintRenderer.render_compartment(context)}"
           end
         end
       end

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

@@ -23,7 +23,10 @@ module Ea
           end
 
           def render_literals_block(context)
-            line_h = context.size + LITERAL_LINE_OFFSET
+            line_h = Ea::Fonts::Metrics.compartment_line_height(
+              context.size, family: context.family, unit: context.size_unit, logical_height: context.logical_height,
+                            offset: LITERAL_LINE_OFFSET
+            )
             text_blocks = []
             row_y = context.geometry.enum_literal_first_y
             # EA renders a centered italic "literals" caption above
@@ -69,12 +72,13 @@ module Ea
           def caption_text(context, y)
             content = "literals"
             len = TextRenderer.estimate_width(content, context.size, nil,
-                                              family: context.family).round
+                                              family: context.family, logical_height: context.logical_height).round
             x = (context.bounds.x + (context.bounds.width - len) / 2.0).floor
             TextRenderer.new(
               content: content,
               x: x, y: y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor,
@@ -87,7 +91,8 @@ module Ea
               content: " ",
               x: context.bounds.x + (context.theme.attribute_spec.visibility_x_offset || 5),
               y: y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor
@@ -100,7 +105,8 @@ module Ea
               content: content,
               x: context.bounds.x + (context.theme.attribute_spec.content_x_offset || 26),
               y: y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               stroke_in_text: context.theme.stroke_in_text_color,
               width_factor: context.theme.text_width_factor

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

@@ -17,7 +17,8 @@ module Ea
               context.header_lines,
               bounds: context.bounds,
               first_y: context.geometry.header_first_y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height,
               fill: context.theme.text_color,
               weight_normal: context.theme.text_weight_normal,
               weight_bold: context.theme.text_weight_bold,

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

@@ -39,10 +39,10 @@ module Ea
             pitch = size + 7
             first_offset = size + 9
             y_index = 0
-            paragraphs = body.to_s.split(/\n/).reject { |p| p.strip.empty? }
+            paragraphs = NoteHtml.paragraphs(body)
             paragraphs.flat_map do |para|
-              lines = wrap_paragraph(para, usable, size, context.family)
-              lines.each_with_index.map do |line, i|
+              lines = wrap_paragraph(para.text, usable, size, context.family)
+              paragraph_svg = lines.each_with_index.map do |line, i|
                 y = context.bounds.y + first_offset + ((y_index + i) * pitch)
                 TextRenderer.new(
                   content: line,
@@ -54,7 +54,9 @@ module Ea
                   stroke_in_text: context.theme.stroke_in_text_color,
                   width_factor: context.theme.text_width_factor
                 ).to_svg
-              end.tap { y_index += lines.size + 1 }
+              end
+              y_index += lines.size + (para.tight ? 0 : 1)
+              paragraph_svg
             end
           end
 

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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.
+        module NoteHtml
+          Paragraph = Struct.new(:text, :tight)
+
+          TAG = %r{</?(?:ul|ol|li|b|i|u|p|br|strong|em)\b[^>]*>}i
+          LINE_BREAK = /<br\b[^>]*>/i
+          LIST_WRAPPER = %r{\A</?(?:ul|ol)>\z}i
+          LIST_ITEM = %r{\A<li>(.*)</li>\z}i
+          ENTITIES = { "&lt;" => "<", "&gt;" => ">", "&amp;" => "&", "&quot;" => '"' }.freeze
+
+          module_function
+
+          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)
+            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
+          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?)
+            segments.each_with_index.map do |segment, index|
+              first = index.zero?
+              [first ? "#{bullet}#{segment}" : segment, first && !bullet.empty?, index < segments.size - 1]
+            end
+          end
+
+          def clean(line)
+            line.gsub(TAG, "").gsub(/&(?:lt|gt|amp|quot);/, ENTITIES).squeeze(" ").strip
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,7 +27,8 @@ module Ea
               context.classifier.operations,
               bounds: context.bounds,
               first_y: context.geometry.op_first_y,
-              family: context.family, size: context.size
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, logical_height: context.logical_height
             )
             parts.join("\n")
           end

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

@@ -12,6 +12,7 @@ module Ea
       module Compartment
         autoload :Shape, "ea/svg/ea_emitter/compartment/shape"
         autoload :NoteBody, "ea/svg/ea_emitter/compartment/note_body"
+        autoload :NoteHtml, "ea/svg/ea_emitter/compartment/note_html"
         autoload :Header, "ea/svg/ea_emitter/compartment/header"
         autoload :HeaderDivider, "ea/svg/ea_emitter/compartment/header_divider"
         autoload :StereotypeIcon, "ea/svg/ea_emitter/compartment/stereotype_icon"