ea 0.6.130 → 0.6.132

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

@@ -9,6 +9,8 @@ module Ea
       # SOID/EOID, EDGE, label boxes) when present. Falls back to
       # the UML-DI owned_element bounds otherwise.
       class DiagramBuilder
+        autoload :UmldiEdges, "ea/sources/xmi/diagram_builder/umldi_edges"
+
         attr_reader :root, :xmi_path
 
         def initialize(root, xmi_path = nil)
@@ -53,6 +55,7 @@ module Ea
             bounds: canvas_bounds(placed_elements),
             style: style_for(ext_diagram),
             style_ex: style_ex_for(ext_diagram),
+            show_notes: style_ex_for(ext_diagram).to_s.include?("ShowNotes=1"),
             elements: build_elements(placed_elements, id, umldi_keywords),
             connectors: build_connectors(placed_connectors,
                                           placed_elements, id),
@@ -144,20 +147,23 @@ module Ea
             acc[pe.style.duid] = pe if pe.style.duid
           end
 
-          placed_connectors.map { |p| build_connector(p, by_duid, owner_id) }
+          placed_connectors.each_with_index.map do |placed, index|
+            build_connector(placed, by_duid, owner_id, index)
+          end
         end
 
-        def build_connector(placed, by_duid, owner_id)
+        def build_connector(placed, by_duid, owner_id, rank)
           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)
+          route = connector_route(placed, source, target, owner_id, ext_meta[:ea_type])
           Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic_id(owner_id, "conn", placed.subject),
             diagram_id: owner_id,
             relationship_ref: placed.subject,
+            paint_order: [rank],
             source_duid: style.soid,
             target_duid: style.eoid,
             source_element_ref: source && synthetic_element_id(owner_id, source),
@@ -166,8 +172,8 @@ module Ea
             target_edge: geom.edge,
             connector_type: ext_meta[:ea_type],
             direction: ext_meta[:direction],
-            waypoints: waypoints,
-            style: {},
+            waypoints: route[:waypoints],
+            style: route[:style],
             line_color: style.color,
             line_width: style.line_width,
             hidden: style.hidden,
@@ -211,11 +217,35 @@ module Ea
           IdNormalizer.synthetic_id(owner_id, "elem", placed.subject)
         end
 
-        def compute_waypoints(geom, source, target)
+        def connector_route(placed, source, target, owner_id, type)
+          native = umldi_waypoints(owner_id, placed) if placed.geometry.bend_points.to_a.empty?
+          points = native || compute_waypoints(placed.geometry, source, target,
+                                               style: placed.style, connector_type: type)
+          native ||= umldi_waypoints(owner_id, placed) if points.empty?
+          { waypoints: native || points, style: native ? { umldi_route: true } : {} }
+        end
+
+        # EA's unique exported edge supplies bendless routes and recovers
+        # routes whose placement endpoints cannot be resolved.
+        def umldi_waypoints(diagram_id, placed)
+          return unless xmi_path
+
+          route = umldi_edges.route_for(diagram_id, placed.subject)
+          route&.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
+        end
+
+        def umldi_edges
+          @umldi_edges ||= UmldiEdges.new(xmi_path)
+        end
+
+        def compute_waypoints(geom, source, target, style:, connector_type:)
           src_bounds = bounds_from_placed(source)
           tgt_bounds = bounds_from_placed(target)
           return [] unless src_bounds && tgt_bounds
 
+          stored = stored_route(geom, style, connector_type, src_bounds, tgt_bounds)
+          return stored if stored
+
           router = Ea::Svg::ConnectorRouter.new(
             source_bounds: src_bounds,
             target_bounds: tgt_bounds,
@@ -229,6 +259,27 @@ module Ea
           end
         end
 
+        # Stored bends are routed by StoredRoute where a QEA rule claims
+        # them; anything else keeps the generic router.
+        def stored_route(geom, style, connector_type, src_bounds, tgt_bounds)
+          offsets = { source: [geom.sx, geom.sy], target: [geom.ex, geom.ey] }
+          points = StoredRoute.new.waypoints(
+            link: StoredRoute::Link.new(style.raw, geom.path.to_s.tr("$", ";"), offset_geometry(geom)),
+            connector_type: connector_type, source: src_bounds, target: tgt_bounds,
+            bends: geom.bend_points.to_a, offsets: offsets, edge: geom.edge
+          )
+          return unless points
+
+          points.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        def offset_geometry(geom)
+          { "SX" => geom.sx, "SY" => geom.sy, "EX" => geom.ex, "EY" => geom.ey }
+            .filter_map { |key, value| "#{key}=#{value};" if value }.join
+        end
+
         def bounds_from_placed(placed)
           return nil unless placed
 
@@ -264,12 +315,16 @@ module Ea
 
           label_boxes.transform_values do |box|
             {
-              "cx" => box.cx, "cy" => box.cy,
               "ox" => box.ox, "oy" => box.oy,
+              "cx" => box.cx, "cy" => box.cy,
+              "hidden" => box.hidden,
               "bold" => box.bold,
               "italic" => box.italic,
               "underline" => box.underline,
-              "align" => box.align
+              "color" => box.color,
+              "alignment" => box.align,
+              "direction" => box.direction,
+              "rotation" => box.rotation
             }
           end
         end

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

@@ -38,8 +38,9 @@ module Ea
         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.
+        # each pair is a bend point. EA stores Y negated (as in QEA
+        # t_diagramlinks.Path); the result uses screen-positive Y,
+        # like element bounds.
         def parse_bend_path(raw)
           return [] if raw.nil? || raw.empty?
 
@@ -49,7 +50,7 @@ module Ea
             x_str, y_str = pair.split(":", 2)
             x = int(x_str)
             y = int(y_str)
-            [x, y] if x && y
+            [x, -y] if x && y
           end
         end
 
@@ -72,7 +73,7 @@ module Ea
         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|
+          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?
@@ -98,6 +99,7 @@ module Ea
             italic: hash["ITA"] == 1,
             underline: hash["UND"] == 1,
             hidden: hash["HDN"] == 1,
+            color: hash["CLR"],
             align: hash["ALN"],
             direction: hash["DIR"],
             rotation: hash["ROT"]
@@ -114,7 +116,7 @@ module Ea
 
         LabelBox = Struct.new(
           :cx, :cy, :ox, :oy,
-          :bold, :italic, :underline, :hidden,
+          :bold, :italic, :underline, :hidden, :color,
           :align, :direction, :rotation,
           keyword_init: true
         )

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

@@ -67,13 +67,14 @@ module Ea
           value == "1" || value == "true" || value == "-1"
         end
 
+        # fontsz is EA's tenths of a point, rendered through GDI's double
+        # rounding (pixels = floor(tenths * 96 / 720), points =
+        # floor(pixels * 72 / 96)). Absent or zero means inherit, as nil.
         def scale_font_size(value)
-          return 13 if value.nil? || value.empty?
+          tenths = int(value)
+          return nil if tenths.nil? || tenths.zero?
 
-          pct = int(value)
-          return 13 if pct.nil? || pct.zero?
-
-          (pct * 13 / 100).round
+          (tenths * 96 / 720 * 72 / 96.0).floor
         end
 
         Style = Struct.new(

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Type names EA stores in the <xmi:Extension><elements> block,
+      # where the UML side only carries a primitive-type href or a
+      # placeholder idref. The xmi gem does not expose operations or
+      # parameters of the extension, so the raw XML is read once.
+      #
+      #   <attribute xmi:idref="ID"><properties type="int"/>
+      #   <operation xmi:idref="ID"><type type="void"/>
+      #   <parameter xmi:idref="ID"><properties type="int"/>
+      class ExtensionTypes
+        def self.from_path(xmi_path)
+          return empty if xmi_path.nil?
+
+          new(Nokogiri::XML(File.read(xmi_path)))
+        end
+
+        def self.empty
+          new(nil)
+        end
+
+        def initialize(document)
+          @attributes = index(document, "attribute", "properties")
+          @returns = index(document, "operation", "type")
+          @parameters = index(document, "parameter", "properties")
+        end
+
+        def attribute_type(id)
+          @attributes[id]
+        end
+
+        def return_type(operation_id)
+          @returns[operation_id]
+        end
+
+        def parameter_type(parameter_id)
+          @parameters[parameter_id]
+        end
+
+        private
+
+        def index(document, owner, child)
+          return {} unless document
+
+          document.xpath(%(//*[local-name()="#{owner}"][@*[local-name()="idref"]])).each_with_object({}) do |node, acc|
+            type = node.at_xpath(%(*[local-name()="#{child}"]/@type))&.value
+            idref = node.at_xpath("@*[local-name()='idref']").value
+            acc[idref] = type unless type.nil? || type.empty?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Builds Ea::Model::InstanceSpecification objects from
+      # uml:InstanceSpecification packaged elements. Slots come from
+      # the `runstate` attribute of the element's Extension entry,
+      # which carries slot names and operators that the typed
+      # `<slot>` children omit.
+      class InstanceBuilder
+        XMI_TYPE = "uml:InstanceSpecification"
+        RUNSTATE_XPATH =
+          %(//*[local-name()="element"]/*[local-name()="extendedProperties"][@runstate])
+
+        attr_reader :root, :xmi_path, :classifiers
+
+        def initialize(root, xmi_path, classifiers)
+          @root = root
+          @xmi_path = xmi_path
+          @classifiers = classifiers
+        end
+
+        def build_all
+          instances = []
+          walk(root.model) do |element, package|
+            instances << build_one(element, package) if element.type == XMI_TYPE
+          end
+          instances
+        end
+
+        private
+
+        def walk(element, package = nil, &block)
+          yield element, package
+          element.packaged_element.each do |inner|
+            walk(inner, inner.type == "uml:Package" ? inner : package, &block)
+          end
+        end
+
+        def build_one(element, package)
+          id = IdNormalizer.from_xmi_id(element.id)
+          properties = extension_properties[id]
+          Ea::Model::InstanceSpecification.new(
+            id: id,
+            name: element.name.to_s,
+            role_name: properties&.alias,
+            classifier_id: IdNormalizer.from_xmi_id(element.classifier),
+            classifier_name: classifier_names[element.classifier],
+            stereotype: properties&.stereotype.to_s,
+            package_id: package && IdNormalizer.from_xmi_id(package.id),
+            package_name: package&.name,
+            qualified_name: qualified_name(element, package),
+            slots: slots_for(id),
+            annotations: AnnotationBuilder.from_element(element, id) +
+                         AnnotationBuilder.from_documentation(properties&.documentation, id)
+          )
+        end
+
+        def qualified_name(element, package)
+          name = element.name.to_s
+          return name if name.empty? || package.nil?
+
+          "#{package.name}::#{name}"
+        end
+
+        def classifier_names
+          @classifier_names ||= classifiers.to_h { |c| [c.id, c.name.to_s] }
+        end
+
+        def extension_properties
+          @extension_properties ||=
+            (root.extension&.elements&.element || []).to_h { |e| [e.idref, e.properties] }
+        end
+
+        def slots_for(id)
+          runstates[id].to_s.scan(Ea::Sources::Qea::InstanceBuilder::RUN_STATE_PATTERN).map do |(name, value, op)|
+            Ea::Model::Slot.new(name: name.to_s, value: value.to_s, op: op.to_s.empty? ? "=" : op)
+          end
+        end
+
+        def runstates
+          @runstates ||= extension_runstates
+        end
+
+        def extension_runstates
+          return {} if xmi_path.nil?
+
+          Nokogiri::XML(File.read(xmi_path))
+                  .xpath(RUNSTATE_XPATH)
+                  .to_h { |node| [node.parent["xmi:idref"], node["runstate"]] }
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module Ea
             owner_id: owner.id,
             qualified_name: "#{owner.name}::#{op.name}",
             return_type_name: return_type_name_for(op),
-            visibility: op.visibility,
+            visibility: op.visibility || "public",
             is_static: boolean(op.is_static),
             is_abstract: boolean(op.is_abstract),
             parameters: build_parameters(op, id),
@@ -30,21 +30,21 @@ module Ea
         private
 
         def build_parameters(op, owner_op_id)
-          op.owned_parameter.map.with_index do |param, idx|
-            direction = param.direction || (idx.zero? ? "return" : "in")
+          op.owned_parameter.reject { |p| p.direction == "return" }.map.with_index do |param, idx|
+            direction = param.direction || "in"
             Ea::Model::Parameter.new(
               id: IdNormalizer.from_xmi_id(param.id) ||
                   IdNormalizer.synthetic_id(owner_op_id, "param", idx.to_s),
               name: param.name || direction,
               ordinal: idx,
               direction: direction,
-              type_name: param.type
+              type_name: param.classifier_type
             )
           end
         end
 
         def return_type_name_for(op)
-          op.owned_parameter.find { |p| p.direction == "return" }&.type
+          op.owned_parameter.find { |p| p.direction == "return" }&.classifier_type
         end
 
         def boolean(value)

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # The xmi gem omits ownedReception, so read those source members
+      # directly rather than inferring operations from extension rows.
+      class ReceptionBuilder
+        def initialize(xmi_path)
+          @xmi_path = xmi_path
+        end
+
+        def grouped_by_owner
+          return {} unless @xmi_path
+
+          @grouped_by_owner ||= read_receptions(Nokogiri::XML(File.read(@xmi_path)))
+        end
+
+        private
+
+        def read_receptions(document)
+          scopes = extension_scopes(document)
+          xpath = '//*[local-name()="Model"]//*[local-name()="packagedElement"]/*[local-name()="ownedReception"]'
+          document.xpath(xpath).each_with_object({}) do |node, grouped|
+            owner_id = xmi_attribute(node.parent, "id")
+            next unless owner_id
+
+            (grouped[owner_id] ||= []) << build_one(node, owner_id, scopes)
+          end
+        end
+
+        def build_one(node, owner_id, scopes)
+          id = xmi_attribute(node, "id") ||
+               IdNormalizer.synthetic_id(owner_id, "reception", node["name"])
+          Ea::Model::Operation.new(
+            id: id, name: node["name"], owner_id: owner_id,
+            qualified_name: "#{node.parent["name"]}::#{node["name"]}",
+            is_reception: true,
+            visibility: node["visibility"] || scopes[id] || "public"
+          )
+        end
+
+        def extension_scopes(document)
+          xpath = '//*[local-name()="Extension"]//*[local-name()="receptions"]/*[local-name()="reception"]'
+          document.xpath(xpath).each_with_object({}) do |node, scopes|
+            id = xmi_attribute(node, "idref")
+            scopes[id] = node["scope"].downcase if id && node["scope"]
+          end
+        end
+
+        def xmi_attribute(node, name)
+          node.at_xpath("@*[local-name()='#{name}']")&.value
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,13 @@ module Ea
       # uml:Generalization, uml:Realization, uml:Dependency) into
       # the appropriate Ea::Model::Relationship subclass.
       class RelationshipBuilder
+        # Connector types that imply an aggregation on the source end
+        # when the end itself records none.
+        AGGREGATION_FOR_CONNECTOR_TYPE = {
+          "Aggregation" => "shared",
+          "Composition" => "composite"
+        }.freeze
+
         attr_reader :root
 
         def initialize(root)
@@ -42,7 +49,7 @@ module Ea
           id = IdNormalizer.from_xmi_id(element.id)
           {
             id: id,
-            name: element.name || element.type&.split(":")&.last&.downcase,
+            name: element.name,
             qualified_name: element.name,
             annotations: AnnotationBuilder.from_element(element, id)
           }
@@ -59,6 +66,41 @@ module Ea
         end
 
         def association_args(element)
+          connector = connector_index[element.id]
+          return owned_end_args(element) unless connector&.source && connector.target
+
+          connector_end_args(element, connector)
+        end
+
+        def connector_end_args(element, connector)
+          source = connector.source
+          target = connector.target
+          {
+            source_id: source.idref,
+            target_id: target.idref,
+            source_role_name: source.role&.name,
+            target_role_name: target.role&.name,
+            source_multiplicity_lower: card_lower(source.type&.multiplicity),
+            source_multiplicity_upper: card_upper(source.type&.multiplicity),
+            target_multiplicity_lower: card_lower(target.type&.multiplicity),
+            target_multiplicity_upper: card_upper(target.type&.multiplicity),
+            source_multiplicity_raw: raw_card(source.type&.multiplicity),
+            target_multiplicity_raw: raw_card(target.type&.multiplicity),
+            source_aggregation: source_aggregation(connector),
+            target_aggregation: target.type&.aggregation || "none",
+            source_navigable: navigable?(element, :source),
+            target_navigable: navigable?(element, :target)
+          }
+        end
+
+        def source_aggregation(connector)
+          flagged = connector.source.type&.aggregation || "none"
+          return flagged unless flagged == "none"
+
+          AGGREGATION_FOR_CONNECTOR_TYPE.fetch(connector.properties&.ea_type, "none")
+        end
+
+        def owned_end_args(element)
           ends = element.member_ends.to_a
           source_id = ends.first&.idref
           target_id = ends.last&.idref
@@ -81,6 +123,24 @@ module Ea
           }
         end
 
+        def raw_card(cardinality)
+          text = cardinality.to_s.strip
+          text.empty? ? nil : text
+        end
+
+        def card_lower(cardinality)
+          text = raw_card(cardinality)
+          Integer(text.split("..").first, exception: false) if text
+        end
+
+        def card_upper(cardinality)
+          text = raw_card(cardinality)
+          return nil unless text
+
+          upper = text.split("..").last
+          upper == "*" ? -1 : Integer(upper, exception: false)
+        end
+
         def generalization_args(element)
           # PackagedElement#generalization is a collection of
           # AssociationGeneralization rows. The "specific" (child)