ea 0.3.1 → 0.4.0

data/lib/ea/model/diagram_connector.rb

@@ -5,15 +5,25 @@ module Ea
     # A connector drawn on a diagram between two DiagramElements.
     # References the underlying Relationship (by id) and the source
     # and target DiagramElements (by id). Carries ordered waypoints
-    # for routing.
+    # for routing plus the EA EDGE codes (1=top, 2=right, 3=bottom,
+    # 4=left, 5..8=diagonal variants) which tell the renderer where
+    # to anchor the line on each end.
     class DiagramConnector < Base
       attribute :diagram_id, :string
       attribute :relationship_ref, :string
       attribute :source_element_ref, :string
       attribute :target_element_ref, :string
+      attribute :source_duid, :string
+      attribute :target_duid, :string
+      attribute :source_edge, :integer
+      attribute :target_edge, :integer
       attribute :waypoints, Waypoint, collection: true, initialize_empty: true
       attribute :label, :string
       attribute :style, :hash, default: -> { {} }
+      attribute :line_color, :integer
+      attribute :line_width, :integer
+      attribute :hidden, :boolean
+      attribute :label_boxes, :hash, default: -> { {} }
 
       json do
         map "id", to: :id
@@ -21,9 +31,17 @@ module Ea
         map "relationshipRef", to: :relationship_ref
         map "sourceElementRef", to: :source_element_ref
         map "targetElementRef", to: :target_element_ref
+        map "sourceDuid", to: :source_duid
+        map "targetDuid", to: :target_duid
+        map "sourceEdge", to: :source_edge
+        map "targetEdge", to: :target_edge
         map "waypoints", to: :waypoints, render_empty: true
         map "label", to: :label
         map "style", to: :style
+        map "lineColor", to: :line_color
+        map "lineWidth", to: :line_width
+        map "hidden", to: :hidden, render_default: true
+        map "labelBoxes", to: :label_boxes
       end
     end
   end

data/lib/ea/model/diagram_element.rb

@@ -5,18 +5,46 @@ module Ea
     # A single placed element on a diagram. References the model
     # element it visualizes (by id), carries pixel bounds and a
     # parsed style map (fill color, line color, font, etc.).
+    #
+    # Carries two distinct bounds:
+    # - `bounds` — logical rect (EA's Left/Top/Right/Bottom)
+    # - `image_bounds` — visual rect including padding (EA's
+    #   imgL/imgT/imgR/imgB); used by EA's SVG renderer for the
+    #   actual `<rect>` width/height
     class DiagramElement < Base
       attribute :diagram_id, :string
       attribute :model_element_ref, :string # id of Classifier/Package/etc.
       attribute :bounds, Bounds
+      attribute :image_bounds, Bounds
       attribute :style, :hash, default: -> { {} } # parsed style fields
+      attribute :background_color, :integer # EA BGR integer
+      attribute :line_color, :integer
+      attribute :line_width, :integer
+      attribute :font_family, :string
+      attribute :font_size, :integer
+      attribute :font_bold, :boolean
+      attribute :font_italic, :boolean
+      attribute :font_underline, :boolean
+      attribute :z_order, :integer # seqno
+      attribute :duid, :string # EA's per-placement DUID for connector resolution
 
       json do
         map "id", to: :id
         map "diagramId", to: :diagram_id
         map "modelElementRef", to: :model_element_ref
         map "bounds", to: :bounds
+        map "imageBounds", to: :image_bounds
         map "style", to: :style
+        map "backgroundColor", to: :background_color
+        map "lineColor", to: :line_color
+        map "lineWidth", to: :line_width
+        map "fontFamily", to: :font_family
+        map "fontSize", to: :font_size
+        map "fontBold", to: :font_bold, render_default: true
+        map "fontItalic", to: :font_italic, render_default: true
+        map "fontUnderline", to: :font_underline, render_default: true
+        map "zOrder", to: :z_order
+        map "duid", to: :duid
       end
     end
   end

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

@@ -23,7 +23,7 @@ module Ea
         end
 
         def self.from_comments(comments, owner_id, kind: "documentation")
-          Array(comments).map { |c| new(owner_id).build(kind, c.body) }
+          Array(comments).map { |c| new(owner_id).build(kind, c.body_element || c.body_attribute) }
         end
 
         def self.comments_on(element)

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

@@ -3,10 +3,11 @@
 module Ea
   module Sources
     module Xmi
-      # Translates XMI uml:Diagram elements into Ea::Model::Diagram
-      # instances. Coordinates come from the UML-DI owned_element
-      # bounds; element references come from the model_element
-      # attribute.
+      # Translates EA diagrams from the XMI source into Ea::Model
+      # instances. Uses the rich placement data inside the
+      # <xmi:Extension> block (Left/Top/Right/Bottom, BCol, font,
+      # SOID/EOID, EDGE, label boxes) when present. Falls back to
+      # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
         attr_reader :root
 
@@ -15,67 +16,186 @@ module Ea
         end
 
         def build_all
-          diagrams = Array(root.model.diagram)
-          diagrams.map { |d| build_one(d) }
+          ext_diagrams = extension_diagrams
+          return [] if ext_diagrams.empty?
+
+          ext_diagrams.map { |d| build_one(d) }
+        end
+
+        # The XMI stores diagrams in two places:
+        # - root.model.diagram — UML-DI shape (often just one or none)
+        # - root.extension.diagrams.diagram — the rich EA extension
+        #   block with placement/style/connector data (the source of
+        #   truth for rendering).
+        # We use the extension block when present; fall back to UML-DI
+        # otherwise.
+        def extension_diagrams
+          ext = root.extension
+          return [] unless ext&.diagrams
+
+          ext.diagrams.diagram.to_a
         end
 
-        def build_one(diagram)
-          id = IdNormalizer.from_xmi_id(diagram.id)
-          ext_diagram = extension_diagram_for(id)
+        def build_one(ext_diagram)
+          id = IdNormalizer.from_xmi_id(ext_diagram.id)
+          ext_elements = ExtensionElements.new(ext_diagram)
+          placed_elements = ext_elements.placed_elements
+          placed_connectors = ext_elements.placed_connectors
+          props = ext_diagram.properties
+
           Ea::Model::Diagram.new(
             id: id,
-            name: ext_diagram&.properties&.name,
-            package_id: ext_diagram&.model&.package,
-            diagram_type: ext_diagram&.properties&.type&.split(":")&.last&.downcase,
-            bounds: bounds_for(diagram),
-            elements: build_elements(diagram, id),
-            connectors: [],
-            annotations: AnnotationBuilder.from_element(diagram, id)
+            name: props&.name || ext_diagram.id,
+            package_id: ext_diagram.model&.package,
+            diagram_type: props&.type&.split(":")&.last&.downcase,
+            bounds: canvas_bounds(placed_elements),
+            elements: build_elements(placed_elements, id),
+            connectors: build_connectors(placed_connectors,
+                                          placed_elements, id),
+            annotations: []
           )
         end
 
         private
 
-        def extension_diagram_for(diagram_id)
-          return nil unless root.extension&.diagrams
+        def canvas_bounds(placed_elements)
+          return nil if placed_elements.empty?
+
+          left = placed_elements.map { |e| e.geometry.img_left || e.geometry.left }.compact.min
+          top = placed_elements.map { |e| e.geometry.img_top || e.geometry.top }.compact.min
+          right = placed_elements.map { |e| e.geometry.img_right || e.geometry.right }.compact.max
+          bottom = placed_elements.map { |e| e.geometry.img_bottom || e.geometry.bottom }.compact.max
+          return nil unless left && top && right && bottom
 
-          root.extension.diagrams.diagram.find { |d| d.id == diagram_id }
+          Ea::Model::Bounds.new(x: 0, y: 0,
+                                 width: right - left,
+                                 height: bottom - top)
         end
 
-        def bounds_for(diagram)
-          first_bounds = diagram.owned_element.flat_map(&:bounds).first
-          return nil unless first_bounds
+        def build_elements(placed, owner_id)
+          placed.map { |p| build_element(p, owner_id) }
+        end
 
-          Ea::Model::Bounds.new(
-            x: first_bounds.x || 0,
-            y: first_bounds.y || 0,
-            width: first_bounds.width || 0,
-            height: first_bounds.height || 0
+        def build_element(placed, owner_id)
+          geom = placed.geometry
+          style = placed.style
+          Ea::Model::DiagramElement.new(
+            id: IdNormalizer.synthetic_id(owner_id, "elem", placed.subject),
+            diagram_id: owner_id,
+            model_element_ref: placed.subject,
+            bounds: build_bounds(geom.left, geom.top, geom.right, geom.bottom),
+            image_bounds: build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom),
+            background_color: style.background_color,
+            line_color: style.line_color,
+            line_width: style.line_width,
+            font_family: style.font_family,
+            font_size: style.font_size,
+            font_bold: style.bold,
+            font_italic: style.italic,
+            font_underline: style.underline,
+            z_order: placed.seqno,
+            duid: style.duid,
+            style: {}
           )
         end
 
-        def build_elements(diagram, owner_diagram_id)
-          diagram.owned_element.flat_map do |oe|
-            oe.bounds.each_with_index.map do |bnd, idx|
-              build_element(oe, bnd, owner_diagram_id, idx)
-            end
+        def build_bounds(left, top, right, bottom)
+          return nil unless left && top && right && bottom
+
+          Ea::Model::Bounds.new(x: left, y: top,
+                                 width: right - left,
+                                 height: bottom - top)
+        end
+
+        def build_connectors(placed_connectors, placed_elements, owner_id)
+          # Index elements by DUID so we can resolve SOID/EOID.
+          by_duid = placed_elements.each_with_object({}) do |pe, acc|
+            acc[pe.style.duid] = pe if pe.style.duid
           end
+
+          placed_connectors.map { |p| build_connector(p, by_duid, owner_id) }
         end
 
-        def build_element(owned_element, bounds, diagram_id, idx)
-          Ea::Model::DiagramElement.new(
-            id: IdNormalizer.synthetic_id(diagram_id, "elem", idx.to_s),
-            diagram_id: diagram_id,
-            model_element_ref: IdNormalizer.from_xmi_id(owned_element.model_element),
-            bounds: Ea::Model::Bounds.new(
-              x: bounds.x || 0,
-              y: bounds.y || 0,
-              width: bounds.width || 0,
-              height: bounds.height || 0
-            ),
-            style: {}
+        def build_connector(placed, by_duid, owner_id)
+          geom = placed.geometry
+          style = placed.style
+          source = by_duid[style.soid]
+          target = by_duid[style.eoid]
+          waypoints = compute_waypoints(geom, source, target)
+          Ea::Model::DiagramConnector.new(
+            id: IdNormalizer.synthetic_id(owner_id, "conn", placed.subject),
+            diagram_id: owner_id,
+            relationship_ref: placed.subject,
+            source_duid: style.soid,
+            target_duid: style.eoid,
+            source_element_ref: source && synthetic_element_id(owner_id, source),
+            target_element_ref: target && synthetic_element_id(owner_id, target),
+            source_edge: geom.edge,
+            target_edge: geom.edge,
+            waypoints: waypoints,
+            style: {},
+            line_color: style.color,
+            line_width: style.line_width,
+            hidden: style.hidden,
+            label_boxes: serialize_label_boxes(geom.label_boxes)
           )
         end
+
+        def synthetic_element_id(owner_id, placed)
+          IdNormalizer.synthetic_id(owner_id, "elem", placed.subject)
+        end
+
+        def compute_waypoints(geom, source, target)
+          src_pt = edge_point(source, geom.edge, :source)
+          tgt_pt = edge_point(target, geom.edge, :target)
+          return [] unless src_pt && tgt_pt
+
+          pts = [src_pt]
+          if geom.sx && geom.sy && (geom.sx.nonzero? || geom.sy.nonzero?)
+            pts << [src_pt[0] + geom.sx, src_pt[1] + geom.sy]
+          end
+          if geom.ex && geom.ey && (geom.ex.nonzero? || geom.ey.nonzero?)
+            pts << [tgt_pt[0] - geom.ex, tgt_pt[1] - geom.ey]
+          end
+          pts << tgt_pt
+          pts.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        def edge_point(placed, edge_code, _end_kind)
+          return nil unless placed
+
+          geom = placed.geometry
+          left = geom.left
+          top = geom.top
+          right = geom.right
+          bottom = geom.bottom
+          return nil unless left && top && right && bottom
+
+          case edge_code
+          when 1 then [(left + right) / 2, top]      # top
+          when 2 then [right, (top + bottom) / 2]    # right
+          when 3 then [(left + right) / 2, bottom]   # bottom
+          when 4 then [left, (top + bottom) / 2]     # left
+          else [(left + right) / 2, (top + bottom) / 2]
+          end
+        end
+
+        def serialize_label_boxes(label_boxes)
+          return {} unless label_boxes
+
+          label_boxes.transform_values do |box|
+            {
+              "cx" => box.cx, "cy" => box.cy,
+              "ox" => box.ox, "oy" => box.oy,
+              "bold" => box.bold,
+              "italic" => box.italic,
+              "underline" => box.underline,
+              "align" => box.align
+            }
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Walks the <xmi:Extension>/<elements> block for a single
+      # EA diagram. Returns two arrays: placed elements and placed
+      # connectors, each carrying the parsed geometry + style data.
+      #
+      # The xmi gem exposes the raw rows via Sparx::Diagram::Elements.
+      # This class adds EA-aware parsing on top.
+      class ExtensionElements
+        attr_reader :diagram
+
+        def initialize(diagram)
+          @diagram = diagram
+        end
+
+        def placed_elements
+          rows.filter_map { |row| build_placed_element(row) }
+        end
+
+        def placed_connectors
+          rows.filter_map { |row| build_placed_connector(row) }
+        end
+
+        private
+
+        def rows
+          elements_collection = diagram&.elements
+          return [] unless elements_collection
+
+          elements_collection.element.to_a
+        end
+
+        def build_placed_element(row)
+          return nil unless row.subject
+
+          placement = ExtensionGeometryParser.parse(row.geometry)
+          return nil unless placement.left || placement.img_left
+
+          style = ExtensionStyleParser.parse(row.style)
+          PlacedElement.new(
+            subject: row.subject,
+            seqno: row.seqno,
+            geometry: placement,
+            style: style
+          )
+        end
+
+        def build_placed_connector(row)
+          return nil unless row.subject
+
+          placement = ExtensionGeometryParser.parse(row.geometry)
+          style = ExtensionStyleParser.parse(row.style)
+          # Connectors carry SOID/EOID in their style; geometry has
+          # only bend routing.
+          return nil unless style.soid && style.eoid
+
+          PlacedConnector.new(
+            subject: row.subject,
+            geometry: placement,
+            style: style
+          )
+        end
+
+        # Value types — the diagram builder translates these into
+        # Ea::Model::DiagramElement / DiagramConnector.
+        PlacedElement = Struct.new(:subject, :seqno, :geometry, :style, keyword_init: true)
+        PlacedConnector = Struct.new(:subject, :geometry, :style, keyword_init: true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Parses EA's packed geometry string from
+      # <xmi:Extension>/<elements>/<element>/@geometry. Returns a
+      # typed Placement struct with separate fields for placement
+      # and bend routing. Label boxes decoded into a Hash keyed by
+      # EA's role names (:llb, :llt, :lrt, :lrb).
+      module ExtensionGeometryParser
+        LABEL_BOX_KEYS = %i[llb llt lrt lrb lmt lmb irhs ilhs].freeze
+
+        module_function
+
+        def parse(geometry_string)
+          return Placement.new if geometry_string.nil? || geometry_string.empty?
+
+          kv = split_pairs(geometry_string)
+          Placement.new(
+            left: int(kv["Left"]),
+            top: int(kv["Top"]),
+            right: int(kv["Right"]),
+            bottom: int(kv["Bottom"]),
+            img_left: int(kv["imgL"]),
+            img_top: int(kv["imgT"]),
+            img_right: int(kv["imgR"]),
+            img_bottom: int(kv["imgB"]),
+            sx: int(kv["SX"]),
+            sy: int(kv["SY"]),
+            ex: int(kv["EX"]),
+            ey: int(kv["EY"]),
+            edge: int(kv["EDGE"]),
+            label_boxes: extract_label_boxes(geometry_string),
+            path: kv["Path"]
+          )
+        end
+
+        def split_pairs(str)
+          str.split(";").filter_map do |pair|
+            next nil unless pair.include?("=")
+            next nil if pair.start_with?("$") # $LLB= etc handled separately
+
+            key, value = pair.split("=", 2)
+            [key, value] if key && value
+          end.to_h
+        end
+
+        def int(value)
+          return nil if value.nil? || value.empty?
+
+          Integer(value)
+        rescue ArgumentError
+          nil
+        end
+
+        def extract_label_boxes(geometry_string)
+          geometry_string.to_s.scan(/\$?([A-Z]{3})=((?:[A-Za-z]{1,4}=-?\d+:)+)/).each_with_object({}) do |(key, body), acc|
+            sym = key.downcase.to_sym
+            next unless LABEL_BOX_KEYS.include?(sym)
+            next if body.nil? || body.empty?
+
+            acc[sym] = parse_label_body(body)
+          end
+        end
+
+        def parse_label_body(body)
+          pairs = body.to_s.split(":").filter_map do |pair|
+            next nil unless pair.include?("=")
+
+            k, v = pair.split("=", 2)
+            [k, int(v)] if k && v
+          end
+          hash = pairs.to_h
+          LabelBox.new(
+            cx: hash["CX"],
+            cy: hash["CY"],
+            ox: hash["OX"],
+            oy: hash["OY"],
+            bold: hash["BLD"] == 1,
+            italic: hash["ITA"] == 1,
+            underline: hash["UND"] == 1,
+            hidden: hash["HDN"] == 1,
+            align: hash["ALN"],
+            direction: hash["DIR"],
+            rotation: hash["ROT"]
+          )
+        end
+
+        Placement = Struct.new(
+          :left, :top, :right, :bottom,
+          :img_left, :img_top, :img_right, :img_bottom,
+          :sx, :sy, :ex, :ey, :edge,
+          :label_boxes, :path,
+          keyword_init: true
+        )
+
+        LabelBox = Struct.new(
+          :cx, :cy, :ox, :oy,
+          :bold, :italic, :underline, :hidden,
+          :align, :direction, :rotation,
+          keyword_init: true
+        )
+      end
+    end
+  end
+end

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/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