ea 0.3.1 → 0.5.0

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

@@ -3,78 +3,275 @@
 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
+        attr_reader :root, :xmi_path
 
-        def initialize(root)
+        def initialize(root, xmi_path = nil)
           @root = root
+          @xmi_path = xmi_path
         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
+          umldi_keywords = keywords_for(id)
+
           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),
+            style: style_for(ext_diagram),
+            style_ex: style_ex_for(ext_diagram),
+            elements: build_elements(placed_elements, id, umldi_keywords),
+            connectors: build_connectors(placed_connectors,
+                                          placed_elements, id),
+            annotations: []
           )
         end
 
+        # EA's XMI stores Style (a.k.a. Style1) in `style1.value` —
+        # the per-diagram feature visibility flags (HideAtts, HideOps,
+        # HideStereo, etc.). Parsed by DisplayConfig alongside
+        # StyleEx.
+        def style_for(ext_diagram)
+          style1 = ext_diagram.style1
+          return nil unless style1
+
+          style1.value
+        end
+
+        # EA's XMI stores StyleEx in the diagram's `style2.value`
+        # attribute (alongside Style1 in `style1.value`). The value
+        # is a semicolon-separated key=value string carrying the
+        # Theme=:NNN identifier and behavioral flags (SuppressFOC,
+        # AttPkg, ShowNotes, etc.) — the same shape our Diagram
+        # model expects in `style_ex`.
+        def style_ex_for(ext_diagram)
+          style2 = ext_diagram.style2
+          return nil unless style2
+
+          style2.value
+        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?
 
-          root.extension.diagrams.diagram.find { |d| d.id == diagram_id }
+          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
+
+          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, umldi_keywords = {})
+          placed.map { |p| build_element(p, owner_id, umldi_keywords) }
+        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, umldi_keywords = {})
+          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,
+            show_tagged_values: style.show_tagged_values,
+            icon_visibility: style.hide_icon&.to_s,
+            z_order: placed.seqno,
+            duid: style.duid,
+            umldi_keyword: umldi_keywords[placed.subject],
+            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)
+        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_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)
+          ext_meta = connector_meta(placed.subject)
+          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,
+            connector_type: ext_meta[:ea_type],
+            direction: ext_meta[:direction],
+            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 connector_meta(subject_id)
+          connector = connector_index[subject_id]
+          return { ea_type: nil, direction: nil } unless connector
+
+          props = connector.properties
+          {
+            ea_type: props&.ea_type,
+            direction: props&.direction
+          }
+        end
+
+        def connector_index
+          @connector_index ||= begin
+            conns = root.extension&.connectors&.connector || []
+            conns.each_with_object({}) do |c, acc|
+              acc[c.idref] = c if c.idref
             end
           end
         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 umldi_extractor
+          return nil unless xmi_path
+
+          @umldi_extractor ||= UmldiKeywordExtractor.new(xmi_path)
+        end
+
+        def keywords_for(diagram_id)
+          return {} unless umldi_extractor
+
+          umldi_extractor.keywords_for_diagram(diagram_id)
+        end
+
+        def synthetic_element_id(owner_id, placed)
+          IdNormalizer.synthetic_id(owner_id, "elem", placed.subject)
+        end
+
+        def compute_waypoints(geom, source, target)
+          src_bounds = bounds_from_placed(source)
+          tgt_bounds = bounds_from_placed(target)
+          return [] unless src_bounds && tgt_bounds
+
+          router = Ea::Svg::ConnectorRouter.new(
+            source_bounds: src_bounds,
+            target_bounds: tgt_bounds,
+            edge_code: geom.edge,
+            source_delta: [geom.sx, geom.sy],
+            target_delta: [geom.ex, geom.ey],
+            bend_path: geom.bend_points || []
           )
+          router.waypoints.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        def bounds_from_placed(placed)
+          return nil unless placed
+
+          g = placed.geometry
+          return nil unless g.left && g.top && g.right && g.bottom
+
+          Ea::Model::Bounds.new(x: g.left, y: g.top,
+                                 width: g.right - g.left,
+                                 height: g.bottom - g.top)
+        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

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,124 @@
+# 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"],
+            bend_points: parse_bend_path(kv["Path"])
+          )
+        end
+
+        # EA's Path= field uses the format `x1:y1$x2:y2$...` where
+        # each pair is a bend point. Coordinates are absolute pixel
+        # positions on the diagram canvas.
+        def parse_bend_path(raw)
+          return [] if raw.nil? || raw.empty?
+
+          raw.split("$").filter_map do |pair|
+            next nil unless pair.include?(":")
+
+            x_str, y_str = pair.split(":", 2)
+            x = int(x_str)
+            y = int(y_str)
+            [x, y] if x && y
+          end
+        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, :bend_points,
+          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,91 @@
+# 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: tri_state_icon(kv["HideIcon"]),
+            show_tagged_values: truthy?(kv["Tag"]),
+            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
+
+        # HideIcon tri-state: "1" → :hidden, "0" → :shown,
+        # missing → nil (use the diagram default, which EA treats
+        # as hidden in practice).
+        def tri_state_icon(value)
+          return nil if value.nil? || value.empty?
+          return :hidden if value == "1" || value == "true" || value == "-1"
+          return :shown if value == "0"
+
+          nil
+        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.zero?
+
+          (pct * 13 / 100).round
+        end
+
+        Style = Struct.new(
+          :background_color, :line_color, :line_width,
+          :font_family, :font_size,
+          :bold, :italic, :underline, :black, :hide_icon,
+          :show_tagged_values,
+          :duid, :soid, :eoid, :mode, :color, :hidden,
+          :raw,
+          keyword_init: true
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts Note elements from EA's XMI extension block.
+      # Notes are documentation entries (`<element xmi:type="uml:Note">`)
+      # inside `<xmi:Extension>/<elements>`. Each carries a
+      # `<properties documentation="..."/>` child with the body text.
+      #
+      # The xmi gem parses Note elements as part of the extension
+      # block; we walk them and project to Ea::Model::Note.
+      class NoteBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def build_all
+          elements = root.extension&.elements
+          return [] unless elements
+
+          elements.element.to_a.filter_map { |e| build_one(e) }
+        end
+
+        private
+
+        def build_one(ext_element)
+          type = ext_element.type
+          return nil unless type == "uml:Note"
+
+          props = ext_element.properties
+          Ea::Model::Note.new(
+            id: ext_element.idref,
+            name: ext_element.name,
+            body: props&.documentation,
+            note_type: "Note"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,7 @@ module Ea
             id: id,
             name: attr.name,
             owner_id: owner.id,
+            type_ref: type_ref_for(attr),
             type_name: type_name_for(attr),
             qualified_name: "#{owner.name}::#{attr.name}",
             multiplicity_lower: parse_lower(attr),
@@ -29,6 +30,7 @@ module Ea
             is_ordered: boolean(attr.is_ordered),
             is_unique: boolean(attr.is_unique),
             aggregation: attr.aggregation || "none",
+            association_id: IdNormalizer.from_xmi_id(attr.association),
             visibility: attr.visibility,
             annotations: AnnotationBuilder.from_element(attr, id)
           )
@@ -44,6 +46,13 @@ module Ea
           attr.uml_type&.idref
         end
 
+        def type_ref_for(attr)
+          # XMI <type xmi:idref=...> is the type classifier's GUID.
+          # The adapter's resolve_type_names walks this against the
+          # model to attach the in-model qualified name.
+          attr.uml_type&.idref
+        end
+
         def parse_lower(attr)
           value = attr.lower_value
           return 1 unless value