ea 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33c72ba92cdcdc2bf8b7ab6791c9654c5a36b26535c8b3a9aa45f94c67722e80
-  data.tar.gz: 71e4e4a5a81f44574323b00eed52dde368f635711f52a19bf8487217cab10531
+  metadata.gz: cf343d41c80cffbd277dd67bf172d0c947ddae898f51dacc1a2fffc3af871b0a
+  data.tar.gz: b554c52026c03c0a431e31140f840fedd495fae447b738c4d9fda4fae30c9eda
 SHA512:
-  metadata.gz: cc6dd9c4e78ae8420d26ca2206915844cd8c6b42a8997c21b16574e20d8f66927b13930436b19f4766752cd409a854f3164032992b11bd950556e17433c12cab
-  data.tar.gz: 561e6da3a121cfc641dc901a0e841a8d9e661aaf9c7832c74e6271723a1d62c4fe85fbb31c43048966783c06aebaf9cc0dd6d081d6479e69708294f6fd68963b
+  metadata.gz: bdec06da4470d865e75c52cbe8c5bec83ae4f242b223e98b436e5c244e8dcf8fd3c9a03bfe3f1ef3eedd9d2443fa52c21544755e8ff9cb3c5e698ee0a4b685f3
+  data.tar.gz: 5db5b284986bd79b3c1165f491d95cb6a5b9cd88d0bcdcab116e77abd92ebd84b267c8f3614850fa669d544085eca6eba52a6eea45c992e42439aa0b38803194

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

@@ -63,11 +63,113 @@ module Ea
                                        link_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
             relationship_ref: ref_for_connector(link_row),
-            waypoints: parse_waypoints(link_row.geometry),
+            waypoints: waypoints_for_link(link_row, diagram_row),
             style: DiagramStyleParser.parse(link_row.style)
           )
         end
 
+        # EA's t_diagramlinks.Geometry field stores connector routing
+        # in a packed format. The leading "X1,Y1,X2,Y2" pair (when
+        # present) is in a coordinate frame that does NOT match the
+        # element rect frame (elements use RectTop < RectBottom with
+        # negative y; geometry uses positive y). Rather than trust
+        # the stored absolute coords, we compute the polyline from
+        # the actual placed-element bounds + the SX/SY/EX/EY delta
+        # fields, which describe the bend routing relative to the
+        # element edges.
+        #
+        # If we can't resolve the source or target element placement
+        # for this diagram, we emit no waypoints (the connector will
+        # be invisible) — better than drawing garbage lines.
+        def waypoints_for_link(link_row, diagram_row)
+          connector = database.find_connector(link_row.connectorid)
+          return [] unless connector
+
+          source_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       connector.start_object_id)
+          target_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       connector.end_object_id)
+          return [] unless source_placement && target_placement
+
+          geom = parse_geometry_fields(link_row.geometry)
+          edge_out = geom[:edge] || 0
+
+          source_point = element_edge_point(source_placement, :source, edge_out)
+          target_point = element_edge_point(target_placement, :target, edge_out)
+          points = [source_point]
+          # SX/SY: delta from source point to first bend.
+          if geom[:sx] && geom[:sy] && (geom[:sx].nonzero? || geom[:sy].nonzero?)
+            points << [source_point[0] + geom[:sx], source_point[1] + geom[:sy]]
+          end
+          # EX/EY: delta from second bend to target point. Reverse
+          # to get from target back to the bend.
+          if geom[:ex] && geom[:ey] && (geom[:ex].nonzero? || geom[:ey].nonzero?)
+            points << [target_point[0] - geom[:ex], target_point[1] - geom[:ey]]
+          end
+          points << target_point
+
+          points.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        # Parse the SX, SY, EX, EY, EDGE key=value pairs out of the
+        # geometry string. Each is `KEY=<int>;`. We deliberately do
+        # NOT extract the leading X1,Y1,X2,Y2 numbers because those
+        # are in a different coordinate frame (see note above).
+        def parse_geometry_fields(geometry)
+          return {} if geometry.nil? || geometry.empty?
+
+          s = geometry.to_s
+          {
+            sx: pick_int(s, /SX=(-?\d+)/),
+            sy: pick_int(s, /SY=(-?\d+)/),
+            ex: pick_int(s, /EX=(-?\d+)/),
+            ey: pick_int(s, /EY=(-?\d+)/),
+            edge: pick_int(s, /EDGE=(-?\d+)/)
+          }
+        end
+
+        def pick_int(str, pattern)
+          match = str.match(pattern)
+          return nil unless match
+
+          Integer(match[1])
+        rescue ArgumentError
+          nil
+        end
+
+        # Find where a given EA object is placed on this diagram.
+        def diagram_object_placement(diagram_id, ea_object_id)
+          objects = database.diagram_objects_for(diagram_id) || []
+          objects.find { |o| o.ea_object_id == ea_object_id }
+        end
+
+        # Compute the connection point on an element's edge for the
+        # given side. EA's `EDGE` field on t_diagramlinks tells us
+        # which edge the connector attaches to:
+        #   1 = top (source), 2 = right, 3 = bottom, 4 = left,
+        #   plus 5/6/7/8 for diagonals (treated as the cardinal here).
+        # We use the center of the chosen edge as the connection point.
+        def element_edge_point(placement, end_kind, edge_code)
+          b = bounds_from_rect(placement)
+          case effective_edge(edge_code, end_kind)
+          when :top    then [b.x + b.width / 2, b.y]
+          when :right  then [b.x + b.width, b.y + b.height / 2]
+          when :bottom then [b.x + b.width / 2, b.y + b.height]
+          when :left   then [b.x, b.y + b.height / 2]
+          else              [b.x + b.width / 2, b.y + b.height / 2]
+          end
+        end
+
+        def effective_edge(edge_code, end_kind)
+          mapping = {
+            1 => :top, 2 => :right, 3 => :bottom, 4 => :left,
+            5 => :top, 6 => :right, 7 => :bottom, 8 => :left
+          }
+          mapping[edge_code.to_i] || :center
+        end
+
         def package_id_for(diagram_row)
           pkg = database.find_package(diagram_row.package_id)
           return nil unless pkg
@@ -106,24 +208,6 @@ module Ea
 
           IdNormalizer.from_guid(conn.ea_guid)
         end
-
-        # EA stores connector geometry as a packed string of x,y
-        # pairs separated by semicolons and pipes. Conservative
-        # parse: extract digit pairs, take first/last as endpoints.
-        def parse_waypoints(geometry)
-          return [] if geometry.nil? || geometry.empty?
-
-          numbers = geometry.to_s.scan(/-?\d+/).map(&:to_i)
-          return [] if numbers.size < 4
-
-          numbers.each_slice(2).filter_map do |xy|
-            next nil if xy.size < 2
-
-            Ea::Model::Waypoint.new(
-              position: Ea::Model::Point.new(x: xy[0], y: xy[1])
-            )
-          end
-        end
       end
     end
   end

data/lib/ea/spa/configuration.rb

@@ -51,6 +51,17 @@ module Ea
         @data["appearance"] || {}
       end
 
+      # Diagram rendering control. Default: true (preserve historical
+      # behavior). Set `diagrams.enabled: false` in the YAML to skip
+      # diagram shards entirely — useful when the renderer output is
+      # not yet production-quality and you'd rather hide diagrams
+      # than ship broken visuals.
+      def render_diagrams?
+        diagrams_cfg = @data["diagrams"].is_a?(Hash) ? @data["diagrams"] : {}
+        enabled = diagrams_cfg.key?("enabled") ? diagrams_cfg["enabled"] : true
+        enabled != false
+      end
+
       # Apply overrides to a model Metadata instance, returning a new
       # one. The original is left untouched.
       def apply_to_metadata(model_metadata)
@@ -61,10 +72,13 @@ module Ea
         hash_to_metadata(merged)
       end
 
-      # Surface the relevant config (ui, appearance) into a hash the
-      # SPA skeleton embeds in its metadata payload.
+      # Surface the relevant config (ui, appearance, diagrams) into
+      # a hash the SPA skeleton embeds in its metadata payload so
+      # the frontend can hide its diagram UI when disabled.
       def view_extras
-        { "ui" => ui, "appearance" => appearance }.reject { |_, v| v.nil? || v.empty? }
+        extras = { "ui" => ui, "appearance" => appearance }
+        extras["diagrams"] = { "enabled" => render_diagrams? }
+        extras.reject { |_, v| v.nil? || v.empty? }
       end
 
       private

data/lib/ea/spa/projector.rb

@@ -43,12 +43,17 @@ module Ea
       end
 
       # Enumerate every (id, kind, shard) triple the SPA can address.
+      # Diagrams are skipped when the configuration disables them.
       def each_shard
         return enum_for(:each_shard) unless block_given?
 
         document.classifiers.each { |c| yield shard_for(c) }
         document.packages.each { |p| yield shard_for(p) }
-        document.diagrams.each { |d| yield shard_for(d) }
+        document.diagrams.each { |d| yield shard_for(d) } if render_diagrams?
+      end
+
+      def render_diagrams?
+        configuration ? configuration.render_diagrams? : true
       end
 
       private

data/lib/ea/svg/connector_path.rb

@@ -2,26 +2,34 @@
 
 module Ea
   module Svg
-    # Renders one DiagramConnector as an SVG <polyline> through
-    # its waypoints. Arrowheads and per-direction routing are
-    # future work; today we emit a straight-segment polyline
-    # matching the source layout.
+    # Renders one DiagramConnector as an SVG <path> through its
+    # waypoints, with an arrowhead at the target end. Matches EA's
+    # convention: filled triangle for navigable associations, filled
+    # diamond for aggregations, open diamond for shared aggregations.
     class ConnectorPath
-      attr_reader :connector
+      ARROW_SIZE = 8
 
-      def initialize(connector)
+      attr_reader :connector, :relationship
+
+      def initialize(connector, relationship: nil)
         @connector = connector
+        @relationship = relationship
       end
 
       def render
         points = waypoints
-        return "" if points.empty?
+        return "" if points.size < 2
+
+        path_d = build_path_d(points)
+        style = StyleResolver.new(connector.style)
 
-        <<~SVG.chomp
-          <polyline points="#{points.join(' ')}"
-                    fill="none" stroke="#{stroke_color}"
-                    stroke-width="#{stroke_width}"/>
-        SVG
+        parts = []
+        parts << %(<g class="connector" data-connector-id="#{escape(connector.id)}">)
+        parts << %(  <path d="#{path_d}" stroke="#{style.stroke_color}" stroke-width="#{style.stroke_width}" fill="none"/>)
+        parts << render_source_marker(points) if source_marker?
+        parts << render_target_marker(points)
+        parts << %(</g>)
+        parts.join("\n            ")
       end
 
       private
@@ -30,16 +38,100 @@ module Ea
         connector.waypoints.filter_map do |wp|
           next unless wp.position
 
-          "#{wp.position.x},#{wp.position.y}"
+          [wp.position.x, wp.position.y]
+        end
+      end
+
+      def build_path_d(points)
+        moves = points.each_with_index.map do |p, idx|
+          prefix = idx.zero? ? "M" : "L"
+          "#{prefix} #{p[0]} #{p[1]}"
+        end
+        moves.join(" ")
+      end
+
+      def source_marker?
+        return false unless relationship
+
+        relationship.is_a?(Ea::Model::Association) &&
+          relationship.source_aggregation != "none"
+      end
+
+      def render_source_marker(points)
+        case relationship.source_aggregation
+        when "composite" then filled_diamond(points.first, points[1])
+        when "shared" then open_diamond(points.first, points[1])
+        else ""
         end
       end
 
-      def stroke_color
-        StyleResolver.new(connector.style).stroke_color
+      def render_target_marker(points)
+        filled_arrow(points.last, points[-2])
       end
 
-      def stroke_width
-        StyleResolver.new(connector.style).stroke_width
+      def filled_arrow(tip, base)
+        return "" unless tip && base
+
+        # Build a triangle pointing from base toward tip
+        bx, by = base
+        tx, ty = tip
+        # Perpendicular vector for the wings
+        dx = tx - bx
+        dy = ty - by
+        len = Math.sqrt(dx * dx + dy * dy)
+        return "" if len.zero?
+
+        ux = dx / len
+        uy = dy / len
+        # Wing points are ARROW_SIZE back from tip, perpendicular
+        back_x = tx - ux * ARROW_SIZE
+        back_y = ty - uy * ARROW_SIZE
+        perp_x = -uy * (ARROW_SIZE / 2.0)
+        perp_y = ux * (ARROW_SIZE / 2.0)
+        w1_x = back_x + perp_x
+        w1_y = back_y + perp_y
+        w2_x = back_x - perp_x
+        w2_y = back_y - perp_y
+        points_str = "#{tx} #{ty} #{w1_x.round(1)} #{w1_y.round(1)} #{w2_x.round(1)} #{w2_y.round(1)}"
+        %(  <polygon points="#{points_str}" fill="black" stroke="black" stroke-width="1"/>)
+      end
+
+      def filled_diamond(tip, base)
+        diamond_polygon(tip, base, fill: "black")
+      end
+
+      def open_diamond(tip, base)
+        diamond_polygon(tip, base, fill: "white")
+      end
+
+      def diamond_polygon(tip, base, fill:)
+        bx, by = base
+        tx, ty = tip
+        dx = tx - bx
+        dy = ty - by
+        len = Math.sqrt(dx * dx + dy * dy)
+        return "" if len.zero?
+
+        ux = dx / len
+        uy = dy / len
+        back_x = tx - ux * ARROW_SIZE
+        back_y = ty - uy * ARROW_SIZE
+        perp_x = -uy * (ARROW_SIZE / 2.0)
+        perp_y = ux * (ARROW_SIZE / 2.0)
+        far_x = tx - ux * (2 * ARROW_SIZE)
+        far_y = ty - uy * (2 * ARROW_SIZE)
+        w1_x = back_x + perp_x
+        w1_y = back_y + perp_y
+        w2_x = back_x - perp_x
+        w2_y = back_y - perp_y
+        points_str = "#{far_x.round(1)} #{far_y.round(1)} #{w1_x.round(1)} #{w1_y.round(1)} #{tx} #{ty} #{w2_x.round(1)} #{w2_y.round(1)}"
+        %(  <polygon points="#{points_str}" fill="#{fill}" stroke="black" stroke-width="1"/>)
+      end
+
+      def escape(text)
+        return "" if text.nil?
+
+        text.to_s.gsub("\"", "&quot;")
       end
     end
   end

data/lib/ea/svg/element_box.rb

@@ -4,11 +4,41 @@ require "ostruct"
 
 module Ea
   module Svg
-    # Renders one DiagramElement as an SVG <g> containing the rect
-    # and a name label. Class-shape rendering (with attribute /
-    # operation compartments) is future work; for now we emit a
-    # simple labeled box that mirrors EA's logical placement.
+    # Renders one DiagramElement as a 3-compartment UML class box,
+    # matching EA's drawing convention:
+    #
+    #   ┌─────────────────────────┐
+    #   │ «Stereotype»            │  ← header (stereotype + name)
+    #   │ qualified::Name         │
+    #   ├─────────────────────────┤
+    #   │ + attr1: Type [0..1]    │  ← attributes
+    #   │ + attr2: Type [0..*]    │
+    #   ├─────────────────────────┤
+    #   │ + op1(arg: T): T        │  ← operations
+    #   └─────────────────────────┘
+    #
+    # The stored element bounds are honored as the outer rectangle;
+    # internal layout (header / attrs / ops heights) is computed
+    # proportionally based on line count.
     class ElementBox
+      HEADER_LINE_HEIGHT = 17
+      ATTR_LINE_HEIGHT   = 17
+      OP_LINE_HEIGHT     = 17
+      TOP_PADDING        = 17
+
+      STEREOTYPE_COLORS = {
+        "featuretype" => "#FFFFCC", # yellow
+        "feature"     => "#FFFFCC",
+        "type"        => "#CCFFCC", # green
+        "datatype"    => "#FFCCFF", # pink
+        "basictype"   => "#FFCCFF",
+        "codelist"    => "#FFCCFF",
+        "enumeration" => "#FFCCFF",
+        "union"       => "#F0E68C", # khaki
+        "adeelement"  => "#F5F5DC"  # beige
+      }.freeze
+      DEFAULT_FILL = "#FFFFFF"
+
       attr_reader :element, :model_index
 
       def initialize(element, model_index:)
@@ -20,31 +50,186 @@ module Ea
         return "" unless element.bounds
 
         b = normalize_bounds(element.bounds)
-        style = StyleResolver.new(element.style)
-        label_text = model_element_name
+        classifier = bound_classifier
+        return render_simple_box(b) unless classifier
+
+        render_class_box(b, classifier)
+      end
+
+      private
 
+      def bound_classifier
+        ref = element.model_element_ref
+        return nil unless ref
+
+        candidate = model_index[ref]
+        return nil unless candidate.is_a?(Ea::Model::Classifier)
+
+        candidate
+      end
+
+      def render_simple_box(bounds)
+        style = StyleResolver.new(element.style)
         <<~SVG.chomp
           <g class="element" data-element-id="#{escape(element.id)}">
-            <rect x="#{b.x}" y="#{b.y}" width="#{b.width}" height="#{b.height}"
-                  fill="#{style.fill_color}" stroke="#{style.stroke_color}"
+            <rect x="#{bounds.x}" y="#{bounds.y}" width="#{bounds.width}" height="#{bounds.height}"
+                  fill="#{fill_color(style)}" stroke="#{style.stroke_color}"
                   stroke-width="#{style.stroke_width}"/>
-            <text x="#{b.x + (b.width / 2.0)}"
-                  y="#{b.y + (b.height / 2.0)}"
+            <text x="#{bounds.x + (bounds.width / 2.0)}"
+                  y="#{bounds.y + (bounds.height / 2.0)}"
                   text-anchor="middle" dominant-baseline="middle"
                   fill="#{style.font_color}"
-                  font-family="sans-serif" font-size="14">#{escape(label_text)}</text>
+                  font-family="sans-serif" font-size="14">#{escape(element.id)}</text>
           </g>
         SVG
       end
 
-      private
+      def render_class_box(bounds, classifier)
+        stereotype = primary_stereotype(classifier)
+        fill = STEREOTYPE_COLORS[stereotype&.downcase] || DEFAULT_FILL
+        style = StyleResolver.new(element.style)
+        stroke = style.stroke_color
+        stroke_width = style.stroke_width
+        font_color = style.font_color
 
-      def model_element_name
-        ref = element.model_element_ref
-        return "(unbound)" unless ref
+        header_lines = build_header_lines(classifier, stereotype)
+        attr_lines = build_attribute_lines(classifier)
+        op_lines = build_operation_lines(classifier)
+
+        header_bottom = bounds.y + header_height(header_lines.size)
+        attrs_bottom = header_bottom + compartment_height(attr_lines.size)
+        ops_bottom = attrs_bottom + compartment_height(op_lines.size)
+
+        parts = []
+        parts << %(<g class="element" data-element-id="#{escape(element.id)}">)
+        parts << render_outer_rect(bounds, fill, stroke, stroke_width)
+        parts << render_header_divider(bounds, header_bottom, stroke, stroke_width)
+        parts << render_attrs_divider(bounds, attrs_bottom, stroke, stroke_width) if op_lines.any?
+        parts << render_header_text(bounds, header_lines, font_color)
+        parts << render_attribute_text(bounds, header_bottom, attr_lines, font_color)
+        parts << render_operation_text(bounds, attrs_bottom, op_lines, font_color)
+        parts << %(</g>)
+        parts.join("\n            ")
+      end
+
+      def build_header_lines(classifier, stereotype)
+        lines = []
+        lines << "«#{stereotype}»" if stereotype && !stereotype.empty?
+        lines << (classifier.qualified_name&.split("::")&.last || classifier.name || "(unnamed)")
+        lines
+      end
+
+      def build_attribute_lines(classifier)
+        return [] unless classifier.properties
+
+        classifier.properties.map do |prop|
+          vis = visibility_marker(prop.visibility)
+          mult = multiplicity_text(prop)
+          type = prop.type_name ? ": #{prop.type_name}" : ""
+          "#{vis} #{prop.name}#{type}#{mult}"
+        end
+      end
+
+      def build_operation_lines(classifier)
+        return [] unless classifier.operations
+
+        classifier.operations.map do |op|
+          vis = visibility_marker(op.visibility)
+          ret = op.return_type_name ? ": #{op.return_type_name}" : ""
+          params = (op.parameters || []).map { |p| "#{p.name}: #{p.type_name || 'T'}" }.join(", ")
+          "#{vis} #{op.name}(#{params})#{ret}"
+        end
+      end
+
+      def visibility_marker(visibility)
+        case visibility&.downcase
+        when "public" then "+"
+        when "private" then "-"
+        when "protected" then "#"
+        when "package" then "~"
+        else "+"
+        end
+      end
+
+      def multiplicity_text(prop)
+        lower = prop.multiplicity_lower
+        upper = prop.multiplicity_upper
+        return "" if lower.nil? && upper.nil?
+        return "" if lower == 1 && upper == 1
+
+        upper_text = upper == -1 ? "*" : upper
+        lower_text = lower || 0
+        return "[0..*]" if lower_text == 0 && upper == -1
+        return "[#{lower_text}]" if lower_text == upper
+
+        "[#{lower_text}..#{upper_text}]"
+      end
+
+      def primary_stereotype(classifier)
+        refs = classifier.stereotype_refs
+        return nil if refs.nil? || refs.empty?
+
+        refs.first.to_s.split("::").last
+      end
+
+      def fill_color(style)
+        stereotype = primary_stereotype_from_style
+        STEREOTYPE_COLORS[stereotype&.downcase] || style.fill_color
+      end
+
+      def primary_stereotype_from_style
+        nil
+      end
+
+      def header_height(line_count)
+        TOP_PADDING + (line_count * HEADER_LINE_HEIGHT)
+      end
+
+      def compartment_height(line_count)
+        return 0 if line_count.zero?
+
+        10 + (line_count * (line_count == 0 ? 0 : (line_count < 3 ? 17 : 17)))
+      end
+
+      def render_outer_rect(bounds, fill, stroke, stroke_width)
+        %(  <rect x="#{bounds.x}" y="#{bounds.y}" width="#{bounds.width}" height="#{bounds.height}" fill="#{fill}" stroke="#{stroke}" stroke-width="#{stroke_width}"/>)
+      end
+
+      def render_header_divider(bounds, y, stroke, stroke_width)
+        %(  <path d="M #{bounds.x} #{y} L #{bounds.x + bounds.width} #{y}" stroke="#{stroke}" stroke-width="#{stroke_width}" fill="none"/>)
+      end
+
+      def render_attrs_divider(bounds, y, stroke, stroke_width)
+        %(  <path d="M #{bounds.x} #{y} L #{bounds.x + bounds.width} #{y}" stroke="#{stroke}" stroke-width="#{stroke_width}" fill="none"/>)
+      end
+
+      def render_header_text(bounds, lines, font_color)
+        center_x = bounds.x + (bounds.width / 2.0)
+        lines.each_with_index.map do |line, idx|
+          y = bounds.y + TOP_PADDING + (idx * HEADER_LINE_HEIGHT) - 4
+          weight = (idx == lines.size - 1) ? "bold" : "normal"
+          %(  <text x="#{center_x}" y="#{y}" text-anchor="middle" fill="#{font_color}" font-family="sans-serif" font-size="13" font-weight="#{weight}">#{escape(line)}</text>)
+        end.join("\n            ")
+      end
+
+      def render_attribute_text(bounds, header_bottom, lines, font_color)
+        return "" if lines.empty?
+
+        left = bounds.x + 5
+        lines.each_with_index.map do |line, idx|
+          y = header_bottom + 14 + (idx * ATTR_LINE_HEIGHT)
+          %(  <text x="#{left}" y="#{y}" text-anchor="start" fill="#{font_color}" font-family="sans-serif" font-size="12">#{escape(line)}</text>)
+        end.join("\n            ")
+      end
+
+      def render_operation_text(bounds, attrs_bottom, lines, font_color)
+        return "" if lines.empty?
 
-        model = model_index[ref]
-        model&.name || "(missing #{ref})"
+        left = bounds.x + 5
+        lines.each_with_index.map do |line, idx|
+          y = attrs_bottom + 14 + (idx * OP_LINE_HEIGHT)
+          %(  <text x="#{left}" y="#{y}" text-anchor="start" fill="#{font_color}" font-family="sans-serif" font-size="12">#{escape(line)}</text>)
+        end.join("\n            ")
       end
 
       def normalize_bounds(bounds)

data/lib/ea/svg/renderer.rb

@@ -52,10 +52,17 @@ module Ea
 
       def render_connectors
         diagram.connectors.map do |conn|
-          ConnectorPath.new(conn).render
+          ConnectorPath.new(conn,
+                             relationship: relationship_for(conn)).render
         end.join("\n            ")
       end
 
+      def relationship_for(connector)
+        return nil unless connector.relationship_ref
+
+        model_index[connector.relationship_ref]
+      end
+
       def pad(bounds)
         p = options[:padding]
         OpenStruct.new(

data/lib/ea/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ea
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-19 00:00:00.000000000 Z
+date: 2026-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model