ea 0.3.1 → 0.4.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Computes the canvas dimensions for the root <svg> element.
+      # Union of all element image_bounds (the padded bounds EA
+      # uses for the visual box), with a 10 px outer margin.
+      # Emits cm dimensions (px / 28.346 at 72 DPI).
+      Canvas = Struct.new(:min_x, :min_y, :width, :height, keyword_init: true) do
+        PX_PER_CM = 28.3464567
+
+        def self.from(diagram)
+          points = []
+          (diagram.elements || []).each do |e|
+            b = e.image_bounds || e.bounds
+            next unless b
+
+            points << [b.x, b.y]
+            points << [b.x + b.width, b.y + b.height]
+          end
+          (diagram.connectors || []).each do |c|
+            (c.waypoints || []).each do |wp|
+              next unless wp.position
+
+              points << [wp.position.x, wp.position.y]
+            end
+          end
+          return new(min_x: 0, min_y: 0, width: 1, height: 1) if points.empty?
+
+          xs = points.map(&:first)
+          ys = points.map(&:last)
+          margin = 10
+          new(
+            min_x: (xs.min || 0) - margin,
+            min_y: (ys.min || 0) - margin,
+            width: (xs.max - xs.min) + (2 * margin),
+            height: (ys.max - ys.min) + (2 * margin)
+          )
+        end
+
+        def view_box
+          "#{min_x} #{min_y} #{width} #{height}"
+        end
+
+        def width_cm
+          format_cm(width)
+        end
+
+        def height_cm
+          format_cm(height)
+        end
+
+        private
+
+        def format_cm(px)
+          return "0cm" if px.nil? || px.zero?
+
+          cm = (px / PX_PER_CM.to_f)
+          format("%.2fcm", cm)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits the connectors layer: for each DiagramConnector, emits
+      # one <g> containing the <path d="M x y L x2 y2..."/> through
+      # its waypoints. Markers (arrowheads, diamonds) are emitted
+      # separately by the Markers emitter.
+      class Connectors
+        attr_reader :diagram
+
+        def initialize(diagram)
+          @diagram = diagram
+        end
+
+        def render
+          paths = visible_connectors.filter_map { |c| path_for(c) }
+          return "" if paths.empty?
+
+          %(<g style="stroke-width:2;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00">\n#{paths.join("\n")}\n</g>)
+        end
+
+        private
+
+        def visible_connectors
+          (diagram.connectors || []).reject(&:hidden)
+        end
+
+        def path_for(connector)
+          pts = waypoints_for(connector)
+          return nil if pts.size < 2
+
+          d = pts.each_with_index.map do |p, idx|
+            "#{idx.zero? ? 'M' : 'L'} #{p[0]} #{p[1]}"
+          end.join(" ")
+          %(  <path d="#{d}" shape-rendering="auto"/>)
+        end
+
+        def waypoints_for(connector)
+          (connector.waypoints || []).filter_map do |wp|
+            next unless wp.position
+
+            [wp.position.x, wp.position.y]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Top-level orchestrator: emits a complete standalone SVG
+      # document matching EA's structure. Calls the layer emitters
+      # in EA's canonical order.
+      class Document
+        BUILD_ID = "1628"
+
+        attr_reader :diagram, :model_index, :options
+
+        def initialize(diagram, model_index:, **_options)
+          @diagram = diagram
+          @model_index = model_index
+        end
+
+        def render
+          canvas = Canvas.from(diagram)
+          layers = [
+            Background.render(canvas),
+            Elements.new(diagram, model_index: model_index).render,
+            Connectors.new(diagram).render,
+            Markers.new(diagram, model_index: model_index).render,
+            Labels.new(diagram).render
+          ].reject { |s| s.nil? || s.empty? }
+
+          <<~SVG
+            <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+            <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+
+            <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">
+            <title></title>
+            <desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>
+
+            #{layers.join("\n\n")}
+            </svg>
+          SVG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits the elements layer: for each DiagramElement on the
+      # diagram, emits the EA-shape group (filled rect) plus the
+      # EA-text group (stereotype + name + attributes + operations).
+      #
+      # Each element is rendered in z_order (ascending). Output
+      # follows EA's pattern of layered groups per element:
+      #
+      #   <g style="fill:COLOR;..."><rect x y w h/></g>
+      #   <g style="fill:#000000;..."><text>...</text></g>
+      #   <g style="..."><path d="M x y L x2 y2"/></g>   (divider)
+      #   <g style="..."><text>attr1</text>...</g>
+      class Elements
+        DEFAULT_FILL = "#FFFFFF"
+        DEFAULT_STROKE = "#000000"
+        DEFAULT_FONT_FAMILY = "Calibri"
+        DEFAULT_FONT_SIZE = 13
+
+        attr_reader :diagram, :model_index
+
+        def initialize(diagram, model_index:)
+          @diagram = diagram
+          @model_index = model_index
+        end
+
+        def render
+          ordered_elements.map { |e| render_one(e) }.join("\n")
+        end
+
+        private
+
+        def ordered_elements
+          (diagram.elements || []).sort_by { |e| e.z_order || 0 }
+        end
+
+        def render_one(element)
+          bounds = element.image_bounds || element.bounds
+          return "" unless bounds
+
+          classifier = model_element_for(element)
+          fill = color_from_ea(element.background_color) || fill_for_classifier(classifier)
+          stroke = color_from_ea(element.line_color) || DEFAULT_STROKE
+          stroke_width = element.line_width || 2
+
+          parts = []
+          parts << render_shape_group(bounds, fill, stroke, stroke_width)
+          parts << render_header_text(element, bounds, classifier)
+          parts << render_divider(bounds, stroke, stroke_width) if classifier
+          parts << render_attribute_text(element, bounds, classifier) if classifier
+          parts.compact.join("\n")
+        end
+
+        def render_shape_group(bounds, fill, stroke, stroke_width)
+          %(<g style="stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#{fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00">\n  <rect x="#{bounds.x}" y="#{bounds.y}" width="#{bounds.width}" height="#{bounds.height}" rx="0.00" shape-rendering="auto"  />\n</g>)
+        end
+
+        def render_header_text(element, bounds, classifier)
+          return "" unless classifier
+
+          lines = header_lines(classifier)
+          return "" if lines.empty?
+
+          family = element.font_family || DEFAULT_FONT_FAMILY
+          size = element.font_size || DEFAULT_FONT_SIZE
+          text_blocks = lines.each_with_index.map do |(text, style), idx|
+            weight = style == :bold ? 700 : 400
+            font_style = style == :italic ? "italic" : "normal"
+            y = bounds.y + 17 + (idx * 17)
+            %(  <text x="#{bounds.x + (bounds.width / 2.0)}" y="#{y}" textLength="#{text.length * 7}" style="font-family:#{family}; font-weight:#{weight}; font-style:#{font_style}; font-size:#{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
+          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{text_blocks.join("\n")}\n</g>)
+        end
+
+        def render_divider(bounds, stroke, stroke_width)
+          y = bounds.y + 50
+          %(<g style="stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#{stroke}; stroke-opacity:1.00">\n  <path d="M #{bounds.x} #{y} L #{bounds.x + bounds.width} #{y}" shape-rendering="auto"/>\n</g>)
+        end
+
+        def render_attribute_text(element, bounds, classifier)
+          return "" unless classifier.properties || classifier.operations
+
+          attr_lines = (classifier.properties || []).map do |p|
+            "+ #{p.name}: #{p.type_name || ''} #{mult_text(p)}"
+          end
+          return "" if attr_lines.empty?
+
+          family = element.font_family || DEFAULT_FONT_FAMILY
+          size = element.font_size || DEFAULT_FONT_SIZE
+          text_blocks = attr_lines.each_with_index.map do |line, idx|
+            y = bounds.y + 68 + (idx * 17)
+            %(  <text x="#{bounds.x + 5}" y="#{y}" textLength="#{line.length * 7}" style="font-family:#{family}; font-weight:400; font-style:normal; font-size:#{size}px; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00 stroke-width:0; white-space: pre;" xml:space="preserve">#{escape(line.strip)}</text>)
+          end
+          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{text_blocks.join("\n")}\n</g>)
+        end
+
+        def header_lines(classifier)
+          lines = []
+          if classifier.is_a?(Ea::Model::Klass) && classifier.is_abstract
+            lines << ["_#{classifier.name}", :italic]
+          elsif classifier.stereotype_refs&.any?
+            lines << ["«#{classifier.stereotype_refs.first}»", :normal]
+            lines << [(classifier.qualified_name || classifier.name).to_s, :bold]
+          else
+            lines << [(classifier.qualified_name || classifier.name).to_s, :bold]
+          end
+          lines
+        end
+
+        def mult_text(p)
+          lower = p.multiplicity_lower
+          upper = p.multiplicity_upper
+          return "" if lower.nil? && upper.nil?
+          return "" if lower == 1 && upper == 1
+
+          "[#{lower || 0}..#{upper == -1 ? "*" : upper}]"
+        end
+
+        def fill_for_classifier(classifier)
+          return DEFAULT_FILL unless classifier
+
+          stereotype = primary_stereotype(classifier)
+          return DEFAULT_FILL unless stereotype
+
+          stereotype_color_resolver.fill_for(stereotype)
+        end
+
+        def stereotype_color_resolver
+          @stereotype_color_resolver ||= Ea::Svg::StereotypeColorResolver.new
+        end
+
+        def primary_stereotype(classifier)
+          refs = classifier.stereotype_refs
+          return nil if refs.nil? || refs.empty?
+
+          refs.first.to_s.split("::").last
+        end
+
+        def model_element_for(element)
+          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 color_from_ea(bgr_int)
+          return nil if bgr_int.nil?
+
+          r = bgr_int & 0xff
+          g = (bgr_int >> 8) & 0xff
+          b = (bgr_int >> 16) & 0xff
+          format("#%02X%02X%02X", r, g, b)
+        end
+
+        def escape(text)
+          return "" if text.nil?
+
+          text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+        end
+      end
+    end
+  end
+end

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/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.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-20 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