ea 0.6.120 → 0.6.121

data/lib/ea/fonts/metrics.rb

@@ -51,6 +51,9 @@ module Ea
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
 
+      # Inferred subpixel steps that reproduce EA's near-half-pixel rounding.
+      GDI_SUBPIXELS = 64
+
       # Carlito/Arial have no CJK glyphs; EA's renderer falls back to
       # a proportional CJK font whose advances measure ~0.709em at
       # the NOMINAL size (not scaled by the per-style factors) —
@@ -89,6 +92,13 @@ module Ea
         (size.to_f * 10 / 7).round
       end
 
+      # Quantize before rounding: near-half-pixel Carlito advances
+      # round up in EA's output. The 1/64px step is inferred.
+      def gdi_pixel_advance(advance, height)
+        ((advance * height * GDI_SUBPIXELS).round / GDI_SUBPIXELS.to_f).round
+      end
+      private_class_method :gdi_pixel_advance
+
       def compact_compartment_font?(size, family:, unit: "pt")
         family.to_s.casecmp("Cambria").zero? && size == 7 && unit == "pt"
       end
@@ -122,7 +132,7 @@ module Ea
             if cjk?(ch.ord)
               cjk_count += 1
             else
-              latin += ((table[cp_key(ch)] || DEFAULT_ADVANCE) * height).round
+              latin += gdi_pixel_advance(table[cp_key(ch)] || DEFAULT_ADVANCE, height)
             end
           end
           return latin + cjk_count * CJK_ADVANCE * size_pt.to_f
@@ -166,7 +176,7 @@ module Ea
 
       # Families whose EA driver quantizes per-glyph advances
       # (fitted from published textLengths).
-      GDI_HEIGHT_FAMILIES = %w[Carlito].freeze
+      GDI_HEIGHT_FAMILIES = %w[Carlito Arial].freeze
 
       def supported_family?(family)
         !resolve_family(family).nil?

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

@@ -150,14 +150,14 @@ module Ea
           )
         end
 
-        # Negative widths inherit the saved object border, then the diagram theme.
+        # Negative widths inherit; QEA zero widths request a one-pixel cosmetic pen.
         def effective_line_width(obj_row, style)
           object = database.find_object(obj_row.ea_object_id)
           [style[:lwth], object&.borderwidth].each do |raw|
             next if raw.nil? || raw.to_s.empty?
 
             width = raw.to_i
-            return width if width >= 0
+            return [width, 1].max if width >= 0
           end
           nil
         end

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

@@ -6,7 +6,7 @@ module Ea
       # Single source of truth for fill + stroke color decisions.
       #
       # Theme :119 applies:
-      #   - Border color (#9A8484) for element strokes
+      #   - Black default element strokes
       #   - Method color for operation text
       # Theme :119 does NOT apply:
       #   - Per-type fill colors (elements use default #FFFFFF)

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

@@ -21,13 +21,8 @@ module Ea
             %(<g style="#{group_style(context)}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
-          # EA wraps note text by MEASURED width (Carlito advances),
-          # not character count: lines break at the last word whose
-          # cumulative integer textLength fits bounds.width - 15.
-          # Verified against EA-published reference SVGs.
           def wrapped_lines(context, body)
-            # EA's note wrap padding is 4: lines fit bounds.width - 4
-            # (9BA1CE54: width 214, longest line tl 210). Pitch and
+            # 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
@@ -41,7 +36,8 @@ module Ea
             y_index = 0
             paragraphs = NoteHtml.paragraphs(body)
             paragraphs.flat_map do |para|
-              lines = wrap_paragraph(para.text, usable, size, context.family)
+              lines = wrap_paragraph(para.text, usable, size, context.family,
+                                     logical_height: context.logical_height)
               paragraph_svg = lines.each_with_index.map do |line, i|
                 y = context.bounds.y + first_offset + ((y_index + i) * pitch)
                 TextRenderer.new(
@@ -50,6 +46,7 @@ module Ea
                   y: y,
                   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
@@ -60,14 +57,18 @@ module Ea
             end
           end
 
-          def wrap_paragraph(para, usable, size, family)
-            words = para.strip.split(/\s+/)
+          # 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.
+          def wrap_paragraph(para, usable, size, family, logical_height: nil)
             lines = []
             current = ""
-            words.each do |word|
+            words = para.strip.split(/\s+/)
+            words.each_with_index do |word, index|
               candidate = current.empty? ? word : "#{current} #{word}"
-              width = TextRenderer.estimate_width(candidate, size, nil,
-                                                  family: family).round
+              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
                 current = candidate
               else

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

@@ -233,7 +233,8 @@ module Ea
         private_class_method :facing_coordinate
 
         def stroke_outline?(connector, bounds)
-          (connector.style.to_h[:lwidth] == "2" || default_model_connector?(connector)) &&
+          (connector.style.to_h[:lwidth] == "2" || default_model_connector?(connector) ||
+           connector.connector_type == "NoteLink") &&
             bounds.all? { |box| box.width.positive? && box.height.positive? } &&
             outline_connector?(connector, bounds)
         end
@@ -311,7 +312,7 @@ module Ea
 
         def outline_connector?(connector, bounds)
           return true if default_model_connector?(connector)
-          return true if %w[Generalization Aggregation].include?(connector.connector_type)
+          return true if %w[Generalization Aggregation NoteLink].include?(connector.connector_type)
 
           return true if association_ray_outline?(connector)
           return false unless stored_association?(connector) || offset_free_association?(connector)

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

@@ -31,22 +31,39 @@ module Ea
           @divider_y_by_ref = divider_y_by_ref
         end
 
+        # EA draws each connector (and its markers) with the pen width
+        # stored in the diagram link style (`LWidth`); links without
+        # the field keep the diagram default.
+        def self.stroke_width_for(connector, default)
+          style = connector.style || {}
+          raw = style[:lwidth] || style["lwidth"]
+          return default if raw.to_s.strip.empty?
+
+          [raw.to_i, 1].max
+        end
+
+        # Layer key for a style group: the plain key at the default
+        # width, suffixed with the width otherwise so layers of
+        # different widths never merge.
+        def self.layer_key(key, width, default)
+          width == default ? key : :"#{key}_w#{width}"
+        end
+
         def layers
-          paths = visible_connectors.filter_map { |c| path_for(c) }
-          return [] if paths.empty?
+          widths = paths_with_widths
 
           if grouped
-            [Layer.new(style_key: LINE_STYLE_KEY, style: line_style,
-                       body: paths.join("\n  "))]
-          else
-            paths.map do |path|
-              Layer.new(style_key: LINE_STYLE_KEY, style: line_style, body: path)
+            widths.group_by(&:first).map do |width, entries|
+              line_layer(width, entries.map(&:last).join("\n  "))
             end
+          else
+            widths.map { |width, path| line_layer(width, path) }
           end
         end
 
-        def line_style
-          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        def line_style(width = stroke_width)
+          "stroke-width:#{width};stroke-linecap:round;stroke-linejoin:bevel; " \
+            "fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
         end
 
         # Backwards-compatible render — joins all layers' `<g>`.
@@ -56,6 +73,18 @@ module Ea
 
         private
 
+        def paths_with_widths
+          visible_connectors.filter_map do |connector|
+            path = path_for(connector)
+            [self.class.stroke_width_for(connector, stroke_width), path] if 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)
+        end
+
         def visible_connectors
           (diagram.connectors || []).select(&:renderable?)
         end

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

@@ -9,32 +9,15 @@ module Ea
         # chevron) when a stereotype provides a custom icon via
         # ShapeScript.
         #
-        # Currently provides hardcoded fallback polygons for the most
-        # common GML stereotypes (FeatureType, Type) since the source
-        # ShapeScript definitions live in EA's encrypted
-        # InternalTechnologies (TODO.diagrams/87). Future enhancement:
-        # read shapescript from MDG files when available.
+        # Only MDG-provided ShapeScript is rendered.
         class StereotypeIconRenderer
-          # Hardcoded fallback icons keyed by stereotype name.
-          # Each entry is [fill, stroke, points_array].
-          FALLBACK_ICONS = {
-            "FeatureType" => ["#FAF1EC", "#69738C",
-                              [[0, -5], [5, 0], [0, 5], [-5, 0]]],
-            "Type" => ["#FAF1EC", "#69738C",
-                       [[0, -5], [5, 0], [0, 5], [-5, 0]]]
-          }.freeze
-
-          # Default position offset from element's center
-          OFFSET_X = 0
-          OFFSET_Y = 0
-
           attr_reader :classifier, :bounds, :canvas, :mdg_registry
 
           # @param mdg_registry [Ea::Mdg::Registry, nil] optional
           #   registry to look up MDG-provided ShapeScript for the
           #   classifier's stereotype. When provided and the matching
           #   stereotype has a ShapeScript body, it's parsed and
-          #   rendered. Otherwise falls back to FALLBACK_ICONS.
+          #   rendered.
           def initialize(classifier:, bounds:, canvas: nil, mdg_registry: nil)
             @classifier = classifier
             @bounds = bounds
@@ -51,12 +34,12 @@ module Ea
             return "" unless classifier && bounds
             return "" unless stereotype_name
 
-            shapescript_svg || fallback_svg
+            shapescript_svg.to_s
           end
 
           private
 
-          # Try MDG-provided ShapeScript first.
+          # Renders MDG-provided ShapeScript for the stereotype.
           # @return [String, nil] SVG fragment from parsed ShapeScript
           def shapescript_svg
             return nil unless mdg_registry
@@ -83,35 +66,12 @@ module Ea
             nil
           end
 
-          # @return [String] hardcoded fallback polygon, or "" if none
-          def fallback_svg
-            spec = FALLBACK_ICONS[stereotype_name]
-            return "" unless spec
-
-            fill, stroke, points = spec
-            cx = bounds.x + bounds.width / 2 + OFFSET_X
-            cy = bounds.y + bounds.height / 2 + OFFSET_Y
-            translated = points.map { |x, y| translate_point(cx + x, cy + y) }
-            pts_str = translated.map { |x, y| coord(x) + "," + coord(y) }.join(" ")
-            %(<polygon points="#{pts_str}" fill="#{fill}" stroke="#{stroke}" stroke-width="1"/>)
-          end
-
           def stereotype_name
             return nil unless classifier.is_a?(Ea::Model::Classifier)
 
             refs = classifier.stereotype_refs
             refs&.first
           end
-
-          def translate_point(x, y)
-            return [x, y] unless canvas
-
-            [canvas.translate_x(x), canvas.translate_y(y)]
-          end
-
-          def coord(value)
-            Ea::Svg::EaEmitter::Canvas.coord(value)
-          end
         end
       end
     end

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

@@ -11,7 +11,7 @@ module Ea
       class Elements
         DEFAULT_FILL = "#FFFFFF"
         DEFAULT_STROKE = "#000000"
-        DEFAULT_STROKE_WIDTH = 2
+        DEFAULT_STROKE_WIDTH = 1
         DEFAULT_TEXT_COLOR = "#000000"
 
         attr_reader :diagram, :model_index, :canvas, :document
@@ -178,6 +178,9 @@ module Ea
                                                                 off_canvas_parent_name: parent_name,
                                                                 foreign_package_name: foreign_package_name_for(classifier),
                                                                 suppress_stereotypes: suppress_stereotypes?) : []
+          header_lines = header_lines.map do |text, style|
+            [text, font_resolver.header_style_for(style, element)]
+          end
           geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                           tagged_values_for(classifier).size,
                                           header_lines, classifier: classifier, family: family,
@@ -257,9 +260,11 @@ module Ea
           # Bag': Set enum box stored h59 -> EA 223 fitting six
           # literals); op-only boxes keep the no-growth behavior
           # (op_bottom_y is a divider sentinel, not content).
+          # Saved boxes may already fit rows with less than the growth
+          # padding. Test the baseline for overflow before adding padding.
           if (attr_lines.any? || enum_literals_for(classifier).any?) &&
              grown_bottom.positive? &&
-             grown_bottom + 8 > bounds.y + bounds.height
+             grown_bottom > bounds.y + bounds.height
             bounds = Ea::Model::Bounds.new(
               x: bounds.x, y: bounds.y,
               width: bounds.width,

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

@@ -43,7 +43,7 @@ module Ea
             return explicit
           end
 
-          theme_family_for(explicit) || diagram_default_family || DEFAULT_FONT_FAMILY
+          default_family_for(explicit)
         end
 
         def size_for(element)
@@ -72,14 +72,29 @@ module Ea
         end
 
         def style_for(element)
-          element&.font_italic ? "italic" : "normal"
+          return "italic" if element&.font_italic
+          return "normal" if element&.style&.key?(:italic)
+
+          diagram.hand_draw ? "italic" : "normal"
+        end
+
+        def header_style_for(style, element)
+          return style unless diagram.hand_draw && style_for(element) == "italic"
+
+          style == :bold ? :bold_italic : style
         end
 
         private
 
+        def default_family_for(explicit)
+          return "Source Sans Pro" if diagram.hand_draw
+
+          theme_family_for(explicit) || diagram_default_family || DEFAULT_FONT_FAMILY
+        end
+
         def theme_family_for(explicit)
           return unless theme.themed?
-          return theme.font_family if DEFAULT_MARKER_FAMILIES.include?(explicit)
+          return theme.font_family || "Carlito" if DEFAULT_MARKER_FAMILIES.include?(explicit)
 
           theme.element_font_family || theme.font_family
         end

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

@@ -4,7 +4,9 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # Navigability arrow at the target end of an association.
+        # Navigability arrow at the target end of an association, plus
+        # the diamond of an association whose end carries an aggregate
+        # flag (SourceIsAggregate/DestIsAggregate).
         # Rendered as a `<path>` (not polygon) sharing style with the
         # connector line. When both ends are navigable
         # (bidirectional association), EA renders a separate arrow at
@@ -16,6 +18,14 @@ module Ea
 
           def self.specs_for(connector, source, target, before_target,
                              after_source, relationship: nil)
+            Diamond.flagged_end_specs(relationship, source, target,
+                                      before_target, after_source) +
+              arrow_specs(connector, source, target, before_target,
+                          after_source)
+          end
+
+          def self.arrow_specs(connector, source, target, before_target,
+                               after_source)
             # EA draws the navigability arrow on directed
             # associations AND aggregations (333EFCCF: 6 aggregations
             # render diamond + path arrow); Direction
@@ -33,6 +43,7 @@ module Ea
             base = whole_end_at_source ? before_target : after_source
             [Registry::Spec.new(shape: :arrow, anchor: anchor, base: base)]
           end
+          private_class_method :arrow_specs
 
           # EA marks truly bidirectional associations with
           # direction="Bi-Directional" on t_connector. These get a

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

@@ -4,8 +4,9 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # EA endpoint fields select the diamond end; direction selects
-        # the arrow end for target-owned aggregations.
+        # EA endpoint fields select the diamond end and its fill (shared
+        # is hollow, composite is solid); direction selects the arrow end
+        # for target-owned aggregations.
         class Diamond < Kind
           def self.handles?(effective_type)
             %w[Aggregation Composition].include?(effective_type)
@@ -15,7 +16,7 @@ module Ea
             whole_at_target = whole_at_target?(connector, relationship)
             whole_anchor = whole_at_target ? target : source
             whole_base = whole_at_target ? before_target : after_source
-            specs = [Registry::Spec.new(shape: :diamond,
+            specs = [Registry::Spec.new(shape: diamond_shape(connector, relationship, whole_at_target),
                                         anchor: whole_anchor,
                                         base: whole_base)]
             return specs unless whole_at_target
@@ -24,6 +25,41 @@ module Ea
                                          before_target, after_source))
           end
 
+          # Diamonds for the ends of a plain association that carry an
+          # aggregate flag.
+          def self.flagged_end_specs(relationship, source, target,
+                                     before_target, after_source)
+            return [] unless relationship
+
+            { target_aggregation: [target, before_target],
+              source_aggregation: [source, after_source] }.filter_map do |reader, (anchor, base)|
+              shape = flagged_shape(relationship.public_send(reader))
+              Registry::Spec.new(shape: shape, anchor: anchor, base: base) if shape
+            end
+          end
+
+          def self.flagged_shape(kind)
+            case kind.to_s
+            when "shared" then :diamond_hollow
+            when "composite" then :diamond
+            end
+          end
+          private_class_method :flagged_shape
+
+          def self.diamond_shape(connector, relationship, whole_at_target)
+            kind = if relationship
+                     whole_at_target ? relationship.target_aggregation : relationship.source_aggregation
+                   end
+            kind = type_default_kind(connector) if kind.to_s.empty? || kind.to_s == "none"
+            kind.to_s == "shared" ? :diamond_hollow : :diamond
+          end
+          private_class_method :diamond_shape
+
+          def self.type_default_kind(connector)
+            connector.connector_type == "Composition" ? "composite" : "shared"
+          end
+          private_class_method :type_default_kind
+
           def self.whole_at_target?(connector, relationship)
             return true if dest_flagged?(relationship)
             return false if source_flagged?(relationship)

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

@@ -15,7 +15,7 @@ module Ea
         class OpenTriangle < Kind
           def self.handles?(effective_type)
             %w[Generalization Realization Realisation Dependency
-               InformationFlow NoteLink].include?(effective_type)
+               InformationFlow].include?(effective_type)
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)

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

@@ -5,30 +5,17 @@ module Ea
     module EaEmitter
       module Marker
         # PackageImport marker for «import» connectors between
-        # packages. EA draws a closed trapezoid silhouette at the
-        # source end (the importing package) and an open V-arrow at
-        # the target end (the imported package) — but ONLY when the
-        # connector's geometry string carries explicit SX/SY offset
-        # fields. Auto-routed connectors (no SX/SY) render as a
-        # plain solid line with no package_anchor marker.
-        #
-        # Verified against both QEAs (output by the same EA run):
-        #   - basic.qea Package Imports: SX=0;SY=0 present → marker
-        #   - plateau Urban Planning ADE2: SX/SY absent → no marker
+        # packages. EA draws the dependency-style open arrowhead at the
+        # target (imported) end, whether or not the diagram link
+        # carries explicit SX/SY offsets.
         class PackageImport < Kind
           def self.handles?(effective_type)
             effective_type == "Package"
           end
 
-          def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
-            return [] unless connector.has_geometry_offsets
-
-            [
-              Registry::Spec.new(shape: :package_anchor,
-                                 anchor: source, base: after_source),
-              Registry::Spec.new(shape: :arrow, anchor: target,
-                                 base: before_target)
-            ]
+          def self.specs_for(_connector, _source, target, before_target, _after_source, **)
+            [Registry::Spec.new(shape: :dependency_arrow,
+                                anchor: target, base: before_target)]
           end
         end
       end

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

@@ -4,16 +4,12 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # Plus-symbol marker at the contained end of a Nesting
-        # connector. EA renders a "+" (16x16, two crossed lines)
-        # at the end pointing INTO the container.
+        # Circled-plus marker at the container end of a Nesting
+        # connector. EA draws a white circle of radius ARM_LENGTH just
+        # outside the container edge with a plus (two crossed arms)
+        # through its centre; the connector starts at the nested
+        # element and ends at the container.
         #
-        # Path encoding (two sub-paths in one <path>):
-        #
-        #   M cx cy-8 L cx cy+8    (vertical arm, 16 tall)
-        #   M cx+8 cy L cx-8 cy    (horizontal arm, 16 wide)
-        #
-        # cx, cy = plus center, anchored at the source-end waypoint.
         class Plus < Kind
           ARM_LENGTH = 8
 
@@ -22,14 +18,10 @@ module Ea
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
-            # Plus is at the contained (child) end. EA's convention:
-            # source end is the child, target end is the parent.
-            # Default to source unless the connector direction
-            # reverses the ends.
-            whole_end_at_source = whole_end_at_source?(connector)
-            anchor = whole_end_at_source ? source : target
-            base = whole_end_at_source ? after_source : before_target
-            [Registry::Spec.new(shape: :plus, anchor: anchor, base: base)]
+            container_at_target = whole_end_at_source?(connector)
+            anchor = container_at_target ? target : source
+            base = container_at_target ? before_target : after_source
+            [Registry::Spec.new(shape: :nesting, anchor: anchor, base: base)]
           end
         end
       end