ea 0.3.0 → 0.4.0

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits connector labels (role names, multiplicities) at the
+      # EA-recorded offset from the connector endpoints. Each label
+      # box has its own position decoded from the EA LLB/LLT/LRT/LRB
+      # geometry slots.
+      class Labels
+        DEFAULT_FAMILY = "Calibri"
+        DEFAULT_SIZE = 10
+
+        attr_reader :diagram
+
+        def initialize(diagram)
+          @diagram = diagram
+        end
+
+        def render
+          texts = visible_connectors.filter_map { |c| texts_for(c) }
+          return "" if texts.empty?
+
+          blocks = texts.flatten
+          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{blocks.join("\n")}\n</g>)
+        end
+
+        private
+
+        def visible_connectors
+          (diagram.connectors || []).reject(&:hidden)
+        end
+
+        def texts_for(connector)
+          points = connector.waypoints.filter_map { |w| w.position && [w.position.x, w.position.y] }
+          return nil if points.size < 2
+
+          source_pt = points.first
+          target_pt = points.last
+
+          boxes = connector.label_boxes || {}
+          texts = []
+          if (box = boxes["llb"]) && box["ox"] && box["oy"]
+            texts << text_at(source_pt[0] + box["ox"], source_pt[1] + box["oy"], connector.label.to_s)
+          end
+          if (box = boxes["lrt"]) && box["ox"] && box["oy"]
+            texts << text_at(target_pt[0] + box["ox"], target_pt[1] + box["oy"], connector.label.to_s)
+          end
+          texts.empty? ? nil : texts
+        end
+
+        def text_at(x, y, text)
+          return nil if text.nil? || text.empty?
+
+          %(  <text x="#{format('%.2f', x)}" y="#{format('%.2f', y)}" textLength="#{text.length * 6}" style="font-family:#{DEFAULT_FAMILY}; font-weight:0; font-style:normal; font-size:#{DEFAULT_SIZE}px; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00 stroke-width:0; white-space: pre;" xml:space="preserve">#{escape(text)}</text>)
+        end
+
+        def escape(text)
+          text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits arrow / diamond markers per connector, matching EA's
+      # convention:
+      #   - Association (navigable): filled triangle at target
+      #   - Generalization: open triangle at target
+      #   - Realization: open triangle at target (path dashed)
+      #   - Dependency: open arrow at target (path dashed)
+      #   - Aggregation (source): open diamond at source
+      #   - Composition (source): filled diamond at source
+      class Markers
+        ARROW_SIZE = 10
+
+        attr_reader :diagram, :model_index
+
+        def initialize(diagram, model_index:)
+          @diagram = diagram
+          @model_index = model_index
+        end
+
+        def render
+          polys = visible_connectors.filter_map { |c| polygon_for(c) }
+          return "" if polys.empty?
+
+          polys.join("\n")
+        end
+
+        private
+
+        def visible_connectors
+          (diagram.connectors || []).reject(&:hidden)
+        end
+
+        def polygon_for(connector)
+          relationship = relationship_for(connector)
+          points = connector.waypoints.filter_map { |w| w.position && [w.position.x, w.position.y] }
+          return nil if points.size < 2
+
+          source = points.first
+          target = points.last
+          before_target = points[-2] || source
+
+          marker = marker_for(relationship)
+          return nil if marker == :none
+
+          polygon = case marker
+                    when :filled_triangle then filled_triangle(target, before_target)
+                    when :open_triangle then open_triangle(target, before_target)
+                    end
+          return nil unless polygon
+
+          style = polygon_style(relationship)
+          %(<g style="#{style}">\n  #{polygon}\n</g>)
+        end
+
+        def marker_for(relationship)
+          return :filled_triangle unless relationship
+
+          case relationship
+          when Ea::Model::Generalization, Ea::Model::Realization
+            :open_triangle
+          else
+            :filled_triangle
+          end
+        end
+
+        def polygon_style(relationship)
+          case marker_for(relationship)
+          when :open_triangle
+            "stroke-width:2;stroke-linecap:round;stroke-linejoin:bevel; fill:#FFFFFF;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+          else
+            "stroke-width:2;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+          end
+        end
+
+        def filled_triangle(tip, base)
+          polygon_points(tip, base, fill: true)
+        end
+
+        def open_triangle(tip, base)
+          polygon_points(tip, base, fill: false)
+        end
+
+        def polygon_points(tip, base, fill:)
+          bx, by = base
+          tx, ty = tip
+          dx = tx - bx
+          dy = ty - by
+          len = Math.sqrt(dx * dx + dy * dy)
+          return nil 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)
+          w1_x = back_x + perp_x
+          w1_y = back_y + perp_y
+          w2_x = back_x - perp_x
+          w2_y = back_y - perp_y
+          pts = "#{tx} #{ty} #{format('%.1f', w1_x)} #{format('%.1f', w1_y)} #{format('%.1f', w2_x)} #{format('%.1f', w2_y)}"
+          %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+        end
+
+        def relationship_for(connector)
+          return nil unless connector.relationship_ref
+
+          model_index[connector.relationship_ref]
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    # EaEmitter orchestrates SVG output that mirrors EA's layering
+    # and naming conventions:
+    #
+    # 1. XML declaration + DOCTYPE (SVG 1.0)
+    # 2. Root <svg> with cm dimensions + viewBox
+    # 3. <title></title> + <desc>Created with Enterprise Architect..</desc>
+    # 4. Background <g> with full-canvas white rect
+    # 5. Per-element groups, layered: shape <g>, text <g>, divider
+    #    <g>, attribute text <g>
+    # 6. Per-connector groups: path <g> and polygon <g>
+    # 7. Final labels <g> with all connector text
+    #
+    # Distinct from Ea::Svg::Renderer which produces a thinner
+    # output for diagrams that don't carry full EA style data.
+    module EaEmitter
+      autoload :Canvas, "ea/svg/ea_emitter/canvas"
+      autoload :Background, "ea/svg/ea_emitter/background"
+      autoload :Elements, "ea/svg/ea_emitter/elements"
+      autoload :Connectors, "ea/svg/ea_emitter/connectors"
+      autoload :Markers, "ea/svg/ea_emitter/markers"
+      autoload :Labels, "ea/svg/ea_emitter/labels"
+      autoload :Document, "ea/svg/ea_emitter/document"
+    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/svg/stereotype_color_resolver.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Ea
+  module Svg
+    # Resolves a classifier's stereotype to a fill color. Looks up
+    # a YAML config (config/stereotype_colors.yml) by lowercase
+    # stereotype name. Falls back to a default white when no match.
+    #
+    # Loading the YAML is memoized at the class level via a
+    # class instance variable accessor method (no instance_variable_set).
+    class StereotypeColorResolver
+      DEFAULT_FILL = "#FFFFFF"
+      DEFAULT_CONFIG_PATH = File.expand_path("../../../config/stereotype_colors.yml", __dir__)
+
+      class << self
+        # Memoize the loaded default map. Re-reading from disk is
+        # expensive; load once per process.
+        def default_map
+          @default_map ||= load_yaml(DEFAULT_CONFIG_PATH)
+        end
+
+        # Test hook: clear the memo to force a reload.
+        def reset_default_map
+          @default_map = nil
+        end
+
+        def load_yaml(path)
+          return {} unless File.exist?(path)
+
+          YAML.safe_load(File.read(path)) || {}
+        end
+      end
+
+      attr_reader :color_map, :default
+
+      def initialize(color_map: self.class.default_map, default: DEFAULT_FILL)
+        @color_map = color_map
+        @default = default
+      end
+
+      def fill_for(stereotype_name)
+        return default if stereotype_name.nil? || stereotype_name.empty?
+
+        color_map[stereotype_name.downcase] || default
+      end
+    end
+  end
+end

data/lib/ea/svg.rb

@@ -14,8 +14,10 @@ module Ea
   module Svg
     autoload :BoundsCalculator, "ea/svg/bounds_calculator"
     autoload :StyleResolver, "ea/svg/style_resolver"
+    autoload :StereotypeColorResolver, "ea/svg/stereotype_color_resolver"
     autoload :ElementBox, "ea/svg/element_box"
     autoload :ConnectorPath, "ea/svg/connector_path"
     autoload :Renderer, "ea/svg/renderer"
+    autoload :EaEmitter, "ea/svg/ea_emitter"
   end
 end

data/lib/ea/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-19 00:00:00.000000000 Z
+date: 2026-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -193,6 +193,17 @@ files:
 - README.adoc
 - README.md
 - Rakefile
+- TODO.diagrams/01-xmi-extension-elements-parsing.md
+- TODO.diagrams/02-diagram-element-rich-model.md
+- TODO.diagrams/03-ea-style-svg-emitter.md
+- TODO.diagrams/04-connector-routing-from-soid-eoid.md
+- TODO.diagrams/05-marker-rendering-per-relationship-type.md
+- TODO.diagrams/06-connector-labels.md
+- TODO.diagrams/07-canvas-size-and-viewbox.md
+- TODO.diagrams/08-visual-regression-harness.md
+- TODO.diagrams/09-cli-render-all-diagrams.md
+- TODO.diagrams/10-stereotype-color-config.md
+- TODO.diagrams/11-elkrb-auto-layout-integration.md
 - TODO.next/00-publish-blocking-bugs.md
 - TODO.next/01-standalone-ea-gem-identity.md
 - TODO.next/02-optional-lutaml-uml-dependency.md
@@ -257,6 +268,7 @@ files:
 - config/diagram_styles.yml
 - config/model_transformations.yml
 - config/qea_schema.yml
+- config/stereotype_colors.yml
 - docs/ea_to_uml_type_mapping.md
 - docs/xmi_qea_conversion_capabilities.md
 - examples/lur/20251010_current_plateau_v5.1.lur
@@ -455,6 +467,9 @@ files:
 - lib/ea/sources/xmi/annotation_builder.rb
 - lib/ea/sources/xmi/classifier_builder.rb
 - lib/ea/sources/xmi/diagram_builder.rb
+- lib/ea/sources/xmi/extension_elements.rb
+- lib/ea/sources/xmi/extension_geometry_parser.rb
+- lib/ea/sources/xmi/extension_style_parser.rb
 - lib/ea/sources/xmi/id_normalizer.rb
 - lib/ea/sources/xmi/metadata_builder.rb
 - lib/ea/sources/xmi/operation_builder.rb
@@ -482,8 +497,17 @@ files:
 - lib/ea/svg.rb
 - lib/ea/svg/bounds_calculator.rb
 - lib/ea/svg/connector_path.rb
+- lib/ea/svg/ea_emitter.rb
+- lib/ea/svg/ea_emitter/background.rb
+- lib/ea/svg/ea_emitter/canvas.rb
+- lib/ea/svg/ea_emitter/connectors.rb
+- lib/ea/svg/ea_emitter/document.rb
+- lib/ea/svg/ea_emitter/elements.rb
+- lib/ea/svg/ea_emitter/labels.rb
+- lib/ea/svg/ea_emitter/markers.rb
 - lib/ea/svg/element_box.rb
 - lib/ea/svg/renderer.rb
+- lib/ea/svg/stereotype_color_resolver.rb
 - lib/ea/svg/style_resolver.rb
 - lib/ea/transformations.rb
 - lib/ea/transformations/configuration.rb