ea 0.3.0 → 0.4.0

data/lib/ea/sources/xmi/extension_style_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Parses EA's packed style string from
+      # <xmi:Extension>/<elements>/<element>/@style. Returns a typed
+      # Style struct so renderers consume typed fields.
+      module ExtensionStyleParser
+        module_function
+
+        def parse(style_string)
+          return Style.new if style_string.nil? || style_string.empty?
+
+          kv = split_pairs(style_string)
+          Style.new(
+            background_color: int(kv["BCol"]),
+            line_color: int(kv["LCol"]),
+            line_width: int(kv["LWth"] || kv["LWidth"]),
+            font_family: kv["font"],
+            font_size: scale_font_size(kv["fontsz"]),
+            bold: truthy?(kv["bold"]),
+            italic: truthy?(kv["italic"]),
+            underline: truthy?(kv["ul"]),
+            black: truthy?(kv["black"]),
+            hide_icon: truthy?(kv["HideIcon"]),
+            duid: kv["DUID"],
+            soid: kv["SOID"],
+            eoid: kv["EOID"],
+            mode: int(kv["Mode"]),
+            color: int(kv["Color"]),
+            hidden: truthy?(kv["Hidden"]),
+            raw: style_string
+          )
+        end
+
+        def split_pairs(str)
+          str.split(";").filter_map do |pair|
+            next nil unless pair.include?("=")
+
+            key, value = pair.split("=", 2)
+            [key, value] if key && value && !value.empty?
+          end.to_h
+        end
+
+        def int(value)
+          return nil if value.nil? || value.empty?
+
+          Integer(value)
+        rescue ArgumentError
+          nil
+        end
+
+        def truthy?(value)
+          value == "1" || value == "true" || value == "-1"
+        end
+
+        def scale_font_size(value)
+          return 13 if value.nil? || value.empty?
+
+          pct = int(value)
+          return 13 if pct.nil?
+
+          (pct * 13 / 100).round
+        end
+
+        Style = Struct.new(
+          :background_color, :line_color, :line_width,
+          :font_family, :font_size,
+          :bold, :italic, :underline, :black, :hide_icon,
+          :duid, :soid, :eoid, :mode, :color, :hidden,
+          :raw,
+          keyword_init: true
+        )
+      end
+    end
+  end
+end

data/lib/ea/sources/xmi.rb

@@ -23,6 +23,9 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
+      autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
+      autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"
+      autoload :ExtensionStyleParser, "ea/sources/xmi/extension_style_parser"
       autoload :Adapter, "ea/sources/xmi/adapter"
     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/ea_emitter/background.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits the background layer: white rect over the full canvas.
+      module Background
+        module_function
+
+        def render(canvas)
+          %(<g style="fill:#FFFFFF;fill-opacity:1.00;">\n  <rect x="#{canvas.min_x}" y="#{canvas.min_y}" width="#{canvas.width}" height="#{canvas.height}" shape-rendering="auto"/>\n</g>)
+        end
+      end
+    end
+  end
+end

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