ea 0.6.129 → 0.6.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29ca7acdd9050d074b2b4db4206b75b9601a6a3241211dc371e4d4d0fb78e0f4
-  data.tar.gz: 12f9fa35b19bfcafac72caceb32217ab2ec98d8fac0cc6cd7e659c3dae0bada6
+  metadata.gz: 1ecc752b8f42a0d41b86681bc355d5f76e87c656ec5f18c2beaeffbbabe6f990
+  data.tar.gz: a5d37a462b9f90e594243b2d0deb2b1692866a846a9e3a57423c6ebd41ea7a13
 SHA512:
-  metadata.gz: 6482340f93e344e5cd7a034d3af0db2152b0738f6f85eb1fb5d0a5114ff119d0b8bd0fa150b5f8e4795e92b8b5743a03f8e668f38a4b5e9ba665bcbf19c1e050
-  data.tar.gz: 2ded830ba84797da9a07c0d9c0e70351292b5e68869f4fce38692774d55977fe3808a4651e35313025644304d9458e03f5b13225a47830013bf8a673f113376a
+  metadata.gz: 011a8bf645f17a054db1fc45e8b078a5436bf8dc57fa27c27a3c91fd8a34178c9f22722ceed040893417335ec472e9f751656be2d471c9f9e252b7ca882a3c44
+  data.tar.gz: 051b2492e102e467b7ea3f6a59edb1a3981ef7579d80fd51a23aaf815434ba90635d155a8c024cfad4d082cf006ae41c33387a2fac2cf9f5188cdc9d6fcefa11

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

@@ -32,9 +32,11 @@ module Ea
             relationships: relationships,
             stereotypes: [],
             notes: notes,
+            instance_specifications: instance_specifications,
             diagrams: diagrams
           )
           apply_tagged_values(doc)
+          apply_receptions(doc)
           apply_stereotypes(doc)
           resolve_type_names(doc)
           doc
@@ -42,6 +44,13 @@ module Ea
 
         private
 
+        def apply_receptions(doc)
+          grouped = ReceptionBuilder.new(xmi_path).grouped_by_owner
+          doc.classifiers.each do |classifier|
+            classifier.operations.concat(grouped.fetch(classifier.id, []))
+          end
+        end
+
         # Attach stereotypes parsed from <xmi:Extension>/<elements>
         # to their owning classifiers and packages.
         def apply_stereotypes(doc)
@@ -90,27 +99,37 @@ module Ea
           end
         end
 
+        # Replaces each type reference with its in-model qualified
+        # name; references that are not classifiers (primitive hrefs,
+        # EA placeholder idrefs) take the type name EA stores in the
+        # extension block.
         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
+          types = ExtensionTypes.from_path(xmi_path)
 
           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
+              prop.type_name = qualified_by_id[prop.type_ref] ||
+                               types.attribute_type(prop.id) || prop.type_name
+            end
+            (classifier.operations || []).each do |op|
+              resolve_operation_types(op, qualified_by_id, types)
             end
           end
         end
 
+        def resolve_operation_types(operation, qualified_by_id, types)
+          operation.return_type_name = qualified_by_id[operation.return_type_name] ||
+                                       types.return_type(operation.id) ||
+                                       operation.return_type_name
+          operation.parameters.each do |param|
+            param.type_name = qualified_by_id[param.type_name] ||
+                              types.parameter_type(param.id) || param.type_name
+          end
+        end
+
         def metadata
           @metadata ||= MetadataBuilder.new(root, xmi_path).build
         end
@@ -123,6 +142,10 @@ module Ea
           @classifiers ||= ClassifierBuilder.new(root).build_all
         end
 
+        def instance_specifications
+          @instance_specifications ||= InstanceBuilder.new(root, xmi_path, classifiers).build_all
+        end
+
         def relationships
           @relationships ||= RelationshipBuilder.new(root).build_all
         end

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

@@ -22,6 +22,14 @@ module Ea
           from_comments(comments, owner_id, kind: kind)
         end
 
+        # Documentation text from the element's Extension properties,
+        # the XMI counterpart of an EA element note.
+        def self.from_documentation(text, owner_id, kind: "documentation")
+          return [] if text.nil? || text.empty?
+
+          [new(owner_id).build(kind, text)]
+        end
+
         def self.from_comments(comments, owner_id, kind: "documentation")
           Array(comments).map { |c| new(owner_id).build(kind, c.body_element || c.body_attribute) }
         end

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

@@ -55,10 +55,20 @@ module Ea
             visibility: element.visibility,
             properties: PropertyBuilder.new.build_all_for(element),
             operations: OperationBuilder.new.build_all_for(element),
-            annotations: AnnotationBuilder.from_element(element, id)
+            annotations: annotations_for(element, id)
           }
         end
 
+        def annotations_for(element, id)
+          AnnotationBuilder.from_element(element, id) +
+            AnnotationBuilder.from_documentation(documentation_by_id[id], id)
+        end
+
+        def documentation_by_id
+          @documentation_by_id ||=
+            (root.extension&.elements&.element || []).to_h { |e| [e.idref, e.properties&.documentation] }
+        end
+
         def enumeration_args(element)
           literals = element.owned_literal.map.with_index do |lit, idx|
             Ea::Model::EnumerationLiteral.new(

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)
@@ -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)

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

@@ -15,6 +15,7 @@ module Ea
           "uml:PrimitiveType" => "Ea::Model::PrimitiveType",
           "uml:Enumeration" => "Ea::Model::Enumeration",
           "uml:Interface" => "Ea::Model::Interface",
+          "uml:Signal" => "Ea::Model::Signal",
         }.freeze
 
         def class_for(xmi_type)

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

@@ -40,6 +40,14 @@ module Ea
 
         private
 
+        # Text of the shape's UMLKeywordLabel child; name labels and
+        # other labelled children never contribute a keyword.
+        def keyword_text(shape)
+          label = shape.xpath("./ownedElement[@*[local-name()=\"type\"]=\"umldi:UMLKeywordLabel\"]").first
+          text = label && label["text"]
+          text unless text.nil? || text.empty?
+        end
+
         def doc
           @doc ||= Nokogiri::XML(File.read(xmi_path))
         end
@@ -47,34 +55,14 @@ module Ea
         def keywords_by_diagram
           @keywords_by_diagram ||= begin
             result = {}
-            # The Sparx XMI export declares the umldi: namespace
-            # but the elements inside Diagram have lost their
-            # prefix binding once parsed by Nokogiri — the
-            # element name resolves to local-name "ownedElement"
-            # and the umldi:UMLClassifierShape type information
-            # lives in the literal `type` attribute. We therefore
-            # match shape children by the presence of `modelElement`
-            # and the keyword label by its `text` attribute.
             doc.xpath("//*[local-name()=\"Diagram\"]").each do |diagram|
               diagram_id = diagram["id"] || diagram["xmi:id"]
               next unless diagram_id
 
               keywords = {}
               diagram.xpath("./ownedElement[@modelElement]").each do |shape|
-                model_id = shape["modelElement"]
-                next unless model_id
-
-                # Keyword label is the first ownedElement child
-                # with a non-empty `text` attribute. The name
-                # label follows it.
-                shape.xpath("./ownedElement[@text]").each do |child|
-                  text = child["text"]
-                  next if text.nil? || text.empty?
-                  next if text.start_with?("«") # safety
-
-                  keywords[model_id] = text
-                  break
-                end
+                text = keyword_text(shape)
+                keywords[shape["modelElement"]] = text if text
               end
               result[diagram_id] = keywords unless keywords.empty?
             end

data/lib/ea/sources/xmi.rb

@@ -18,14 +18,17 @@ module Ea
       autoload :MetadataBuilder, "ea/sources/xmi/metadata_builder"
       autoload :PackageBuilder, "ea/sources/xmi/package_builder"
       autoload :ClassifierBuilder, "ea/sources/xmi/classifier_builder"
+      autoload :InstanceBuilder, "ea/sources/xmi/instance_builder"
       autoload :PropertyBuilder, "ea/sources/xmi/property_builder"
       autoload :OperationBuilder, "ea/sources/xmi/operation_builder"
+      autoload :ReceptionBuilder, "ea/sources/xmi/reception_builder"
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :TagBuilder, "ea/sources/xmi/tag_builder"
       autoload :NoteBuilder, "ea/sources/xmi/note_builder"
       autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
+      autoload :ExtensionTypes, "ea/sources/xmi/extension_types"
       autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
       autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"
       autoload :ExtensionStyleParser, "ea/sources/xmi/extension_style_parser"

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.129"
+  VERSION = "0.6.131"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.129
+  version: 0.6.131
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -853,12 +853,15 @@ files:
 - lib/ea/sources/xmi/extension_elements.rb
 - lib/ea/sources/xmi/extension_geometry_parser.rb
 - lib/ea/sources/xmi/extension_style_parser.rb
+- lib/ea/sources/xmi/extension_types.rb
 - lib/ea/sources/xmi/id_normalizer.rb
+- lib/ea/sources/xmi/instance_builder.rb
 - lib/ea/sources/xmi/metadata_builder.rb
 - lib/ea/sources/xmi/note_builder.rb
 - lib/ea/sources/xmi/operation_builder.rb
 - lib/ea/sources/xmi/package_builder.rb
 - lib/ea/sources/xmi/property_builder.rb
+- lib/ea/sources/xmi/reception_builder.rb
 - lib/ea/sources/xmi/relationship_builder.rb
 - lib/ea/sources/xmi/relationship_type_map.rb
 - lib/ea/sources/xmi/stereotype_builder.rb