ea 0.4.0 → 0.5.0

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Pure parser for EA's `t_xref.Description` mini-language.
+        # Stateless — every call returns a fresh `Xref::Record`.
+        #
+        # Supported formats:
+        #   @STEREO;Name=X;FQName=Y;@ENDSTEREO;
+        #   @PROP=@NAME=..@ENDNAME;@TYPE=..@ENDTYPE;@VALU=..@ENDVALU;@PRMT=..@ENDPRMT;@ENDPROP;
+        #   <key>=<value>;<key>=<value>;
+        #
+        # Unknown formats fall through to key=value parsing.
+        module Parser
+          module_function
+
+          # Parse one Description string into a typed Record.
+          # @param description [String, nil]
+          # @return [Ea::Sources::Qea::Xref::Record]
+          def parse(description)
+            return Record.new if description.nil? || description.empty?
+
+            Record.new(
+              stereotype: parse_stereotype(description),
+              properties: parse_properties(description),
+              legends: parse_legends(description),
+              key_values: parse_key_values(description),
+              raw: description
+            )
+          end
+
+          # -- per-format extractors ----------------------------------
+
+          # Matches both legacy `@STEREO;Name=X;GUID={..};` and the
+          # plateau form `@STEREO;Name=X;FQName=Y;@ENDSTEREO;`.
+          STEREO_REGEX = /
+            @STEREO;
+            (.*?)
+            (?:@ENDSTEREO;|\z)
+          /mx.freeze
+
+          def parse_stereotype(description)
+            match = description.match(STEREO_REGEX)
+            return nil unless match
+
+            fields = parse_semicolon_fields(match[1])
+            StereotypeApplication.new(
+              name: fields["Name"],
+              fqname: fields["FQName"]
+            )
+          end
+
+          # One Description can carry multiple @PROP=...@ENDPROP; blocks.
+          # Split, then classify each as PropertyDefinition or LegendDefinition.
+          PROP_REGEX = /
+            @PROP=
+            (.*?)
+            @ENDPROP;
+          /mx.freeze
+
+          def parse_properties(description)
+            blocks = description.scan(PROP_REGEX).flatten
+            blocks.each_with_object([]) do |block, acc|
+              record = build_prop_record(block)
+              acc << record if record
+            end
+          end
+
+          def parse_legends(description)
+            parse_properties(description).select do |prop|
+              prop.is_a?(LegendDefinition)
+            end
+          end
+
+          def build_prop_record(block)
+            name = extract_tagged_value(block, "NAME")
+            type = extract_tagged_value(block, "TYPE")
+            value = extract_tagged_value(block, "VALU")
+            parameter = extract_tagged_value(block, "PRMT")
+
+            if type&.start_with?("LEGEND_")
+              LegendDefinition.new(
+                name: name,
+                legend_type: type,
+                colors: parse_color_value(value),
+                parameter: parameter
+              )
+            else
+              PropertyDefinition.new(
+                name: name,
+                type: type,
+                value: value,
+                parameter: parameter
+              )
+            end
+          end
+
+          # Extracts the content between @TAG=...@ENDTAG; markers.
+          # Returns nil when the tag is absent.
+          def extract_tagged_value(block, tag)
+            pattern = /@#{tag}=(.*?)@END#{tag};/m.freeze
+            match = block.match(pattern)
+            match ? match[1] : nil
+          end
+
+          # EA encodes legend VALU as `#key#=value;` pairs.
+          # Returns a hash keyed by underscored symbol.
+          def parse_color_value(value)
+            return {} if value.nil? || value.empty?
+
+            value.scan(/#([^#=]+)#=([^;]*);/).each_with_object({}) do |(k, v), acc|
+              acc[k.downcase.to_sym] = v
+            end
+          end
+
+          # Legacy `Key=Value;Key=Value;` parsing. Skips content that
+          # looks like @STEREO or @PROP blocks to avoid noise.
+          def parse_key_values(description)
+            stripped = description
+                       .gsub(/@STEREO;.*?(?:@ENDSTEREO;|\z)/m, "")
+                       .gsub(/@PROP=.*?@ENDPROP;/m, "")
+            pairs = stripped.split(";").map { |s| s.split("=", 2) }
+            pairs.each_with_object({}) do |(k, v), acc|
+              next if k.nil? || k.empty? || v.nil?
+
+              acc[k.downcase.to_sym] = v
+            end
+          end
+
+          # Parse `Key=Value;Key=value;` into a string-keyed hash.
+          # Used internally for the @STEREO body fields.
+          def parse_semicolon_fields(body)
+            body.split(";").each_with_object({}) do |part, acc|
+              key, value = part.split("=", 2)
+              next if key.nil? || key.empty? || value.nil?
+
+              # Strip @END* terminators that may be attached when the
+              # body wasn't cleanly split (defensive — usually already
+              # consumed by STEREO_REGEX).
+              cleaned = value.sub(/@END\w+\z/, "")
+              acc[key] = cleaned
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Tagged-value / property definition record. Produced when the
+        # Description contains one or more `@PROP=@NAME=..@ENDNAME;`
+        # blocks for non-legend properties.
+        #
+        # Example source:
+        #   @PROP=@NAME=isActive@ENDNAME;@TYPE=Boolean@ENDTYPE;
+        #         @VALU=@ENDVALU;@PRMT=@ENDPRMT;@ENDPROP;
+        PropertyDefinition = Struct.new(:name, :type, :value, :parameter,
+                                        keyword_init: true) do
+          # @return [Boolean] true when the value field is non-empty
+          def default_value?
+            !value.nil? && !value.empty?
+          end
+
+          # @return [Boolean] true when the property is declared as Boolean
+          def boolean?
+            type == "Boolean"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Parsed t_xref.Description. Holds typed records for each block
+        # found in the source string. One Description can carry multiple
+        # records (e.g., several `@PROP=` blocks defining a stereotype's
+        # tagged-value set).
+        #
+        # Consumers branch on record type without re-parsing strings.
+        Record = Struct.new(:stereotype, :properties, :legends,
+                            :key_values, :raw, keyword_init: true) do
+          def initialize(*)
+            super
+            self.properties ||= []
+            self.legends ||= []
+            self.key_values ||= {}
+          end
+
+          # @return [Boolean] true when a stereotype application is present
+          def stereotype?
+            !stereotype.nil?
+          end
+
+          # @return [Boolean] true when at least one legend is present
+          def legend?
+            !legends.empty?
+          end
+
+          # Convenience: first legend's name (the legend's title).
+          # @return [String, nil]
+          def legend_title
+            legends.first&.name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Stereotype application record. Produced when the Description
+        # starts with `@STEREO;`. Captures the short name and the
+        # fully-qualified `tech::Stereo` form when present.
+        #
+        # Example source:
+        #   @STEREO;Name=FeatureType;FQName=GML::FeatureType;@ENDSTEREO;
+        StereotypeApplication = Struct.new(:name, :fqname, keyword_init: true) do
+          # Returns the technology prefix from FQName, or nil.
+          # @return [String, nil]
+          def technology
+            return nil unless fqname
+
+            idx = fqname.index("::")
+            idx ? fqname[0, idx] : nil
+          end
+
+          # Returns the stereotype name without technology prefix.
+          # Falls back to +name+ when FQName is absent.
+          # @return [String, nil]
+          def unqualified_name
+            if fqname && fqname.include?("::")
+              fqname.split("::", 2).last
+            else
+              name
+            end
+          end
+        end
+      end
+    end
+  end
+end

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
         )