ea 0.4.0 → 0.5.1

data/lib/ea/sources/qea/xref.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Namespace for parsing EA's `t_xref.Description` mini-language.
+      #
+      # EA encodes semi-structured metadata in a custom format combining:
+      #
+      # - Stereotype application: `@STEREO;Name=X;FQName=Y;@ENDSTEREO;`
+      # - Property definitions: `@PROP=@NAME=..@ENDNAME;@TYPE=..@ENDTYPE;...`
+      # - Legend definitions:    `@PROP=@NAME=..;@TYPE=LEGEND_OBJECTSTYLE;...`
+      # - Legacy key=value:      `aggregation=composite;direction=source;`
+      #
+      # The parser returns a typed `Xref::Record` value object so consumers
+      # can branch on record type without re-parsing strings (OCP/MECE).
+      module Xref
+        autoload :Parser, "ea/sources/qea/xref/parser"
+        autoload :Record, "ea/sources/qea/xref/record"
+        autoload :StereotypeApplication,
+                 "ea/sources/qea/xref/stereotype_application"
+        autoload :PropertyDefinition, "ea/sources/qea/xref/property_definition"
+        autoload :LegendDefinition, "ea/sources/qea/xref/legend_definition"
+      end
+    end
+  end
+end

data/lib/ea/sources/qea.rb

@@ -22,9 +22,13 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/qea/relationship_builder"
       autoload :StereotypeBuilder, "ea/sources/qea/stereotype_builder"
       autoload :TaggedValueBuilder, "ea/sources/qea/tagged_value_builder"
+      autoload :NoteBuilder, "ea/sources/qea/note_builder"
       autoload :AnnotationBuilder, "ea/sources/qea/annotation_builder"
+      autoload :InstanceBuilder, "ea/sources/qea/instance_builder"
+      autoload :LegendBuilder, "ea/sources/qea/legend_builder"
       autoload :DiagramBuilder, "ea/sources/qea/diagram_builder"
       autoload :DiagramStyleParser, "ea/sources/qea/diagram_style_parser"
+      autoload :Xref, "ea/sources/qea/xref"
       autoload :Adapter, "ea/sources/qea/adapter"
     end
   end

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

@@ -25,18 +25,92 @@ module Ea
         end
 
         def to_document
-          Ea::Model::Document.new(
+          doc = Ea::Model::Document.new(
             metadata: metadata,
             packages: packages,
             classifiers: classifiers,
             relationships: relationships,
             stereotypes: [],
+            notes: notes,
             diagrams: diagrams
           )
+          apply_tagged_values(doc)
+          apply_stereotypes(doc)
+          resolve_type_names(doc)
+          doc
         end
 
         private
 
+        # Attach stereotypes parsed from <xmi:Extension>/<elements>
+        # to their owning classifiers and packages.
+        def apply_stereotypes(doc)
+          grouped = StereotypeBuilder.new(root).grouped_by_element
+          return if grouped.empty?
+
+          doc.classifiers.each do |c|
+            next unless c.id
+
+            refs = grouped[c.id]
+            next unless refs
+
+            c.stereotype_refs = refs
+          end
+          doc.packages.each do |p|
+            next unless p.id
+
+            refs = grouped[p.id] || grouped["EAID_#{p.id[5..]}"]
+            next unless refs
+
+            p.stereotype_refs = refs
+          end
+        end
+
+        # Attach tagged values parsed from the <xmi:Extension><tags>
+        # block to their owning classifiers and packages.
+        def apply_tagged_values(doc)
+          grouped = TagBuilder.new(xmi_path).grouped_by_model_element
+          return if grouped.empty?
+
+          doc.classifiers.each do |c|
+            next unless c.id
+
+            tags = grouped[c.id]
+            next unless tags
+
+            c.tagged_values = tags
+          end
+          doc.packages.each do |p|
+            next unless p.id
+
+            tags = grouped[p.id] || grouped["EAID_#{p.id[5..]}"]
+            next unless tags
+
+            p.tagged_values = tags
+          end
+        end
+
+        def resolve_type_names(doc)
+          # In the XMI, the <type xmi:idref=...> is the type
+          # classifier's GUID. The property's type_name was
+          # pre-populated by PropertyBuilder with the same idref;
+          # we replace it with the in-model qualified name when
+          # the referenced classifier is loaded.
+          qualified_by_id = doc.classifiers.each_with_object({}) do |c, acc|
+            acc[c.id] = c.qualified_name if c.id && c.qualified_name
+          end
+
+          doc.classifiers.each do |classifier|
+            (classifier.properties || []).each do |prop|
+              ref = prop.type_ref
+              next if ref.nil? || ref.empty?
+
+              resolved = qualified_by_id[ref]
+              prop.type_name = resolved if resolved
+            end
+          end
+        end
+
         def metadata
           @metadata ||= MetadataBuilder.new(root, xmi_path).build
         end
@@ -54,7 +128,11 @@ module Ea
         end
 
         def diagrams
-          @diagrams ||= DiagramBuilder.new(root).build_all
+          @diagrams ||= DiagramBuilder.new(root, xmi_path).build_all
+        end
+
+        def notes
+          @notes ||= NoteBuilder.new(root).build_all
         end
       end
     end

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

@@ -73,8 +73,17 @@ module Ea
         end
 
         def qualified_name(element, containing_package)
+          # The XMI's `name` attribute may already be in
+          # "ns:Class" form (e.g. "xs:string" lives in the `xs`
+          # package). Forcing the package name in front would
+          # produce "xs::xs:string". Strip the existing namespace
+          # prefix from the simple name before composing the
+          # qualified name.
+          raw = element.name.to_s
+          simple = raw.split(":").last
+          simple = raw if simple.nil? || simple.empty?
           pkg_name = containing_package&.name
-          pkg_name ? "#{pkg_name}::#{element.name}" : element.name
+          pkg_name ? "#{pkg_name}::#{simple}" : simple
         end
 
         def boolean(value)

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

@@ -9,10 +9,11 @@ module Ea
       # 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
@@ -42,6 +43,7 @@ module Ea
           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,
@@ -49,13 +51,39 @@ module Ea
             package_id: ext_diagram.model&.package,
             diagram_type: props&.type&.split(":")&.last&.downcase,
             bounds: canvas_bounds(placed_elements),
-            elements: build_elements(placed_elements, id),
+            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 canvas_bounds(placed_elements)
@@ -72,11 +100,11 @@ module Ea
                                  height: bottom - top)
         end
 
-        def build_elements(placed, owner_id)
-          placed.map { |p| build_element(p, owner_id) }
+        def build_elements(placed, owner_id, umldi_keywords = {})
+          placed.map { |p| build_element(p, owner_id, umldi_keywords) }
         end
 
-        def build_element(placed, owner_id)
+        def build_element(placed, owner_id, umldi_keywords = {})
           geom = placed.geometry
           style = placed.style
           Ea::Model::DiagramElement.new(
@@ -93,8 +121,11 @@ module Ea
             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
@@ -122,6 +153,7 @@ module Ea
           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,
@@ -132,6 +164,8 @@ module Ea
             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,
@@ -141,28 +175,71 @@ module Ea
           )
         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 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_pt = edge_point(source, geom.edge, :source)
-          tgt_pt = edge_point(target, geom.edge, :target)
-          return [] unless src_pt && tgt_pt
+          src_bounds = bounds_from_placed(source)
+          tgt_bounds = bounds_from_placed(target)
+          return [] unless src_bounds && tgt_bounds
 
-          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|
+          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
 

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

@@ -32,10 +32,27 @@ module Ea
             ey: int(kv["EY"]),
             edge: int(kv["EDGE"]),
             label_boxes: extract_label_boxes(geometry_string),
-            path: kv["Path"]
+            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?("=")
@@ -91,7 +108,7 @@ module Ea
           :left, :top, :right, :bottom,
           :img_left, :img_top, :img_right, :img_bottom,
           :sx, :sy, :ex, :ey, :edge,
-          :label_boxes, :path,
+          :label_boxes, :path, :bend_points,
           keyword_init: true
         )
 

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

@@ -23,7 +23,8 @@ module Ea
             italic: truthy?(kv["italic"]),
             underline: truthy?(kv["ul"]),
             black: truthy?(kv["black"]),
-            hide_icon: truthy?(kv["HideIcon"]),
+            hide_icon: tri_state_icon(kv["HideIcon"]),
+            show_tagged_values: truthy?(kv["Tag"]),
             duid: kv["DUID"],
             soid: kv["SOID"],
             eoid: kv["EOID"],
@@ -34,6 +35,17 @@ module Ea
           )
         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?("=")
@@ -59,7 +71,7 @@ module Ea
           return 13 if value.nil? || value.empty?
 
           pct = int(value)
-          return 13 if pct.nil?
+          return 13 if pct.nil? || pct.zero?
 
           (pct * 13 / 100).round
         end
@@ -68,6 +80,7 @@ module Ea
           :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

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

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts per-element stereotype applications from EA's
+      # `<xmi:Extension>/<elements>` block. EA stores stereotype
+      # info in `<element xmi:idref="EAID_...">/<properties
+      # stereotype="X"/>`. The uml:Model packaged elements carry
+      # type info but not stereotypes.
+      #
+      # Returns a Hash{element_id => Array<String>} of stereotype
+      # names applied to that element.
+      class StereotypeBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def grouped_by_element
+          @grouped ||= begin
+            elements = root.extension&.elements
+            return {} unless elements
+
+            elements.element.each_with_object({}) do |ext_element, acc|
+              id = ext_element.idref
+              next unless id
+
+              stereotypes = stereotypes_for(ext_element)
+              next if stereotypes.empty?
+
+              acc[id] = stereotypes
+            end
+          end
+        end
+
+        private
+
+        # The `<properties stereotype="X"/>` attribute holds the
+        # primary stereotype. Additional stereotypes from `<xrefs>`
+        # are not captured here — that would require parsing the
+        # packed XREFPROP string format.
+        def stereotypes_for(ext_element)
+          props = ext_element.properties
+          value = props&.stereotype
+          return [] if value.nil? || value.to_s.empty?
+
+          [value.to_s]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts tagged values from the `<xmi:Extension><tags><tag/>`
+      # block. The xmi gem does not expose Sparx tags directly, so we
+      # parse the raw XML once and group tags by their
+      # `modelElement` attribute. Each tag's value is truncated at
+      # the first `#` (EA encodes notes after that marker).
+      class TagBuilder
+        attr_reader :xmi_path
+
+        def initialize(xmi_path)
+          @xmi_path = xmi_path
+        end
+
+        # Returns Hash{model_element_id => Array<Ea::Model::TaggedValue>}
+        def grouped_by_model_element
+          return {} if xmi_path.nil?
+
+          @grouped ||= begin
+            doc = Nokogiri::XML(File.read(xmi_path))
+            # <tags><tag/></tags> lives inside per-element <element>
+            # blocks within <xmi:Extension>. The element itself is in
+            # no XML namespace; match by local-name to be safe.
+            doc.xpath(%(//*[local-name()="tags"]/*[local-name()="tag"]))
+              .each_with_object({}) do |node, acc|
+              me = node["modelElement"]
+              next unless me
+
+              key = node["name"].to_s
+              value = node["value"].to_s.split("#", 2).first
+              next if key.empty?
+
+              (acc[me] ||= []) << Ea::Model::TaggedValue.new(key: key, value: value)
+            end
+          end
+        end
+      end
+    end
+  end
+end