ea 0.5.2 → 0.6.0

data/lib/ea/transformers/qea_to_xmi/guid_format.rb

@@ -1,56 +1,13 @@
 # frozen_string_literal: true
 
+# This file preserves backward compatibility for callers that
+# reference `Ea::Transformers::QeaToXmi::GuidFormat`. The canonical
+# implementation now lives at `Ea::GuidFormat` (shared across
+# subsystems — DRY, MECE). See lib/ea/guid_format.rb.
 module Ea
   module Transformers
     module QeaToXmi
-      # Pure conversions between Sparx EA GUID strings and XMI identifier
-      # strings. No state, no I/O — same input always yields same output.
-      #
-      # EA stores identifiers as `{ABCD-1234-...}` braced GUID strings. XMI
-      # serializations use unbraced, dash→underscore forms prefixed with
-      # `EAID_` (most elements) or `EAPK_` (packages at the model root).
-      module GuidFormat
-        # Braces and dashes both become underscores; collapse runs of
-        # consecutive underscores so `{AB-CD}` → `AB_CD` (not `_AB_CD_`).
-        SEP = /[-{}]/
-
-        module_function
-
-        # @param ea_guid [String, nil] e.g. "{AB-CD-EF}"
-        # @param prefix [String] "EAID" (default) or "EAPK"
-        # @return [String, nil] e.g. "EAID_AB_CD_EF"
-        def ea_guid_to_xmi_id(ea_guid, prefix: "EAID")
-          return nil if ea_guid.nil? || ea_guid.empty?
-
-          clean = ea_guid.gsub(SEP, "_").gsub(/_+/, "_").gsub(/\A_/, "").gsub(/_\z/, "")
-          "#{prefix}_#{clean}"
-        end
-
-        # @param xmi_id [String, nil] e.g. "EAID_AB_CD_EF"
-        # @return [String, nil] e.g. "{AB-CD-EF}"
-        def xmi_id_to_ea_guid(xmi_id)
-          return nil if xmi_id.nil? || xmi_id.empty?
-
-          body = xmi_id.sub(/\A(?:EAID|EAPK)_/, "")
-          "{#{body.tr('_', '-')}}"
-        end
-
-        # Build a member-end xmi:id for one side of a connector.
-        #
-        # Sparx EA's convention: take the connector's GUID, drop the first two
-        # hex characters of its first segment, and prepend `src` or `dst`.
-        #
-        # @param connector_xmi_id [String] e.g. "EAID_AB12CDEF_..."
-        # @param side [Symbol] :source or :destination
-        # @return [String] e.g. "EAID_src2CDEF_..."
-        def connector_end_xmi_id(connector_xmi_id, side:)
-          tag = side == :source ? "src" : "dst"
-          body = connector_xmi_id.sub(/\A(?:EAID|EAPK)_/, "")
-          first_segment, rest = body.split("_", 2)
-          trimmed = first_segment.length > 2 ? first_segment[2..] : first_segment
-          rest ? "EAID_#{tag}#{trimmed}_#{rest}" : "EAID_#{tag}#{trimmed}"
-        end
-      end
+      GuidFormat = ::Ea::GuidFormat
     end
   end
 end

data/lib/ea/transformers/qea_to_xmi/id_allocator.rb

@@ -4,87 +4,88 @@ module Ea
   module Transformers
     module QeaToXmi
       # Allocates synthetic xmi:id values for elements that don't have a
-      # natural GUID-based one — e.g. literal `<lowerValue>` nodes, or
-      # `<ownedComment>` bodies synthesized from EA's Note objects.
+      # natural GUID-based one — literal `<lowerValue>`/`<upperValue>`
+      # bounds, instance slots and their values, return parameters.
       #
-      # Sparx's EAID format reserves prefixes like `LI` (LiteralInt),
-      # `SL` (Slot), `NL` (NameLabel), `DB` (DiagramBounds), `OE` (OpaqueExpr),
-      # `RT` (Return parameter) for these synthesized identifiers.
+      # EA's scheme, derived from examples/exports/*/model.xml:
       #
-      # Output shape: `EAID_<PREFIX><NNNNNN><GUID_TAIL>` where:
+      #   EAID_<PREFIX><NNNNNN><SEP><TAIL27>
       #
-      # - `EAID_` matches the prefix used by all other Sparx XMI element IDs.
-      # - `<PREFIX>` is a Sparx-reserved literal prefix (LI, SL, OE, ...).
-      # - `<NNNNNN>` is a 6-digit zero-padded counter, scoped to the
-      #   IdAllocator instance (one per `Transformer#serialize` call).
-      # - `<GUID_TAIL>` is the parent element's EA GUID normalised to
-      #   Sparx's wire form. The leading underscore from the opening
-      #   brace of `{GUID-...}` is preserved so the output matches
-      #   real Sparx XMI byte-for-byte (e.g. `EAID_LI000001__EEB1_...`).
-      #   When `parent_guid` is nil, no tail is emitted.
+      # - `<PREFIX>` is a Sparx-reserved literal prefix (LI, SL, OE, RT).
+      # - `<NNNNNN>` is a 6-digit zero-padded counter. LI counts GLOBALLY
+      #   from 1 in allocation order (lower before upper, destination end
+      #   before source end, document walk order across owners). SL, OE
+      #   and RT count from 0 PER OWNING ELEMENT (slots/values per
+      #   InstanceSpecification, return parameters per operation).
+      # - `<TAIL27>` is the owner ID's last 27 characters (the EA GUID
+      #   minus its first segment).
+      # - `<SEP>` is as many underscores as keep the synthesized ID the
+      #   same total width as the owner ID (one for 41-char EAID_ owners,
+      #   two for 42-char src/dst association-end owners).
       #
-      # The allocator is memoised by `seed`: same seed returns the same
-      # allocated ID. Different seeds get different counters.
+      # The allocator memoizes by [owner_id, prefix, seed]: the same
+      # triple always returns the same ID without advancing any counter.
+      #
+      # @api private — internal to the QeaToXmi transformer; its
+      # signature follows the transformer's needs, not semver.
       class IdAllocator
         # Well-known prefixes Sparx uses for synthesized IDs.
         LITERAL_INTEGER   = "LI"
         OPAQUE_EXPRESSION = "OE"
         SLOT              = "SL"
-        NAME_LABEL        = "NL"
-        DIAGRAM_BOUNDS    = "DB"
         RETURN_PARAMETER  = "RT"
 
-        # Leading-underscore-preserving normalisation: `{AB-CD}` → `_AB_CD`.
-        # Matches the wire form Sparx emits for parent-guid-suffixed IDs.
-        GUID_BRACE_OR_DASH = /[-{}]/
+        # Prefixes whose counter runs across the whole document, starting
+        # at 1. All other prefixes restart at 0 per owner.
+        GLOBAL_PREFIXES = [LITERAL_INTEGER].freeze
+
+        TAIL_LENGTH = 27
+        # "EAID_" plus the 8-character prefix+counter token.
+        HEAD_LENGTH = 13
 
         def initialize
-          @counter = 0
+          @global_counters = Hash.new(0)
+          @owner_counters = Hash.new(0)
           @assigned = {}
         end
 
-        # @param prefix [String] one of LITERAL_INTEGER, OPAQUE_EXPRESSION, ...
-        # @param seed [String, nil] stable seed for memoization (e.g. the
-        #   source record's object_id). Same seed returns same allocated id.
-        # @param parent_guid [String, nil] the owning element's EA GUID
-        #   (e.g. `{EEB1-...}`). When provided, the synthesised ID carries
-        #   the parent GUID tail so it is traceable and round-trip-safe.
+        # @param prefix [String] LITERAL_INTEGER, SLOT, OPAQUE_EXPRESSION
+        #   or RETURN_PARAMETER
+        # @param owner_id [String] the owning element's full xmi:id — its
+        #   last 27 characters become the tail and its width sets the
+        #   separator
+        # @param seed [String] stable memoization key within the owner
         # @return [String] e.g. "EAID_LI000001__EEB1_4de7_98F5_670D6EE4A52B"
-        def allocate(prefix:, seed: nil, parent_guid: nil)
-          return @assigned[seed] if seed && @assigned.key?(seed)
+        def allocate(prefix:, owner_id:, seed:)
+          key = [owner_id, prefix, seed]
+          return @assigned[key] if @assigned.key?(key)
 
-          @counter += 1
-          id = compose_id(prefix: prefix, n: @counter, parent_guid: parent_guid)
-          @assigned[seed] = id if seed
-          id
+          @assigned[key] = compose_id(prefix, next_counter(prefix, owner_id), owner_id)
         end
 
         private
 
-        def compose_id(prefix:, n:, parent_guid:)
-          tail = guid_tail(parent_guid)
-          if tail
-            # The format is `EAID_LI<NN>_<guid_tail>` where guid_tail
-            # preserves its leading underscore. Together with the
-            # separator `_` that yields the double-underscore form
-            # Sparx emits (`EAID_LI000001__EEB1_...`).
-            format("EAID_%<prefix>s%<n>06d_%<tail>s", prefix: prefix, n: n, tail: tail)
+        def next_counter(prefix, owner_id)
+          if GLOBAL_PREFIXES.include?(prefix)
+            @global_counters[prefix] += 1
           else
-            format("EAID_%<prefix>s%<n>06d", prefix: prefix, n: n)
+            n = @owner_counters[[prefix, owner_id]]
+            @owner_counters[[prefix, owner_id]] = n + 1
+            n
           end
         end
 
-        # Sparx preserves the leading underscore that comes from the
-        # opening brace of the EA GUID. Strip the closing-brace trailing
-        # underscore only.
-        #
-        # `{EEB1-4de7-98F5-670D6EE4A52B}` → `_EEB1_4de7_98F5_670D6EE4A52B`
-        def guid_tail(parent_guid)
-          return nil if parent_guid.nil? || parent_guid.empty?
+        def compose_id(prefix, counter, owner_id)
+          # QEA guid columns are nullable — an owner with no id (or one
+          # too short to carry a 27-char tail) gets a tailless,
+          # counter-only identifier.
+          return format("EAID_%<prefix>s%<n>06d", prefix: prefix, n: counter) if
+            owner_id.to_s.length < TAIL_LENGTH + HEAD_LENGTH
 
-          parent_guid
-            .gsub(GUID_BRACE_OR_DASH, "_")
-            .sub(/_\z/, "")
+          tail = owner_id[-TAIL_LENGTH..]
+          separator = "_" * (owner_id.length - TAIL_LENGTH - HEAD_LENGTH)
+          format("EAID_%<prefix>s%<n>06d%<sep>s%<tail>s",
+                 prefix: prefix, n: counter, sep: separator, tail: tail)
         end
       end
     end

data/lib/ea/transformers/qea_to_xmi/primitive_types.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformers
+    module QeaToXmi
+      # Owns the `EAnone_` id shape and EA's <primitivetypes> Extension
+      # hierarchy: every distinct attribute/operation type name with a
+      # blank classifier becomes an `EAnone_<name>` PrimitiveType
+      # definition, in table first-use order (attributes then operations
+      # — verified to match the reference exports' ordering).
+      #
+      # `definition_id` is also what the transformer's type REFERENCES
+      # go through, so a reference and its definition normalize the name
+      # identically and cannot end up as two different ids.
+      #
+      # Names EA maps to OMG standard primitives are excluded on the
+      # attribute side only, and only when the classifier is blank, since
+      # that is the sole case where the attribute carries an href child
+      # instead of an idref.
+      #
+      # KNOWN GAP: a non-blank classifier that resolves to nothing (a
+      # numeric t_object id from a referenced model) still emits an
+      # `EAnone_` reference with no definition behind it. Defining those
+      # here over-emits instead: this scan walks every row in the
+      # database, including rows the package walk never exports, and EA's
+      # own plateau export defines nothing for them. Closing it means
+      # deriving definitions from the references the walk actually
+      # emitted, which is its own change.
+      module PrimitiveTypes
+        # EA primitive names that reference the OMG PrimitiveTypes
+        # library instead of a synthesized EAnone_ definition.
+        HREF_NAMES = { "int" => "Integer" }.freeze
+
+        OMG_PRIMITIVES = "http://www.omg.org/spec/UML/20110701/PrimitiveTypes.xmi"
+
+        module_function
+
+        # @param database [Ea::Qea::Database]
+        # @return [Array<String>] distinct unresolved type names, first-use order
+        def unresolved_names(database)
+          (attribute_names(database) + operation_names(database)).uniq
+        end
+
+        # An attribute reaches the OMG library through an href child only
+        # when it has no classifier to point at. One that names a
+        # classifier resolves against it instead, so it needs no
+        # definition here — see the KNOWN GAP above for the case where
+        # that classifier resolves to nothing.
+        def attribute_names(database)
+          database.attributes.filter_map do |attr|
+            next nil if href_for(attr.type, attr.classifier)
+
+            unresolved_name(attr.type, attr.classifier)
+          end
+        end
+
+        # Operation returns have no href mechanism — they reference
+        # EAnone_<name> directly, so every name they use must be
+        # defined here or the idref dangles.
+        def operation_names(database)
+          database.operations.filter_map { |op| unresolved_name(op.type, op.classifier) }
+        end
+
+        def unresolved_name(type, classifier)
+          name = normalize_name(type)
+          return nil if name.empty?
+          return nil unless blank_classifier?(classifier)
+
+          name
+        end
+
+        # The id EA gives a type name that has no classifier behind it.
+        # The reference and the definition both come from here, so they
+        # cannot normalize the name differently.
+        # @return [String] e.g. "EAnone_int"
+        def definition_id(type_name)
+          "EAnone_#{normalize_name(type_name)}"
+        end
+
+        # EA type columns are free text; leading/trailing space is not
+        # part of the name.
+        def normalize_name(type)
+          type.to_s.strip
+        end
+
+        # The OMG href replaces the EAnone_ idref only when there is no
+        # classifier to point at. Nil means "not an href target", so the
+        # definition side and the transformer read one expression rather
+        # than asking a predicate and then fetching what it proved.
+        # @return [String, nil] OMG href for EA primitive names, else nil
+        def href_for(type, classifier)
+          return nil unless blank_classifier?(classifier)
+
+          target = HREF_NAMES[normalize_name(type)]
+          target && "#{OMG_PRIMITIVES}##{target}"
+        end
+
+        def blank_classifier?(classifier)
+          text = normalize_name(classifier)
+          text.empty? || text == "0"
+        end
+      end
+    end
+  end
+end

data/lib/ea/transformers/qea_to_xmi/profile_serializer.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "xmi"
+
+module Ea
+  module Transformers
+    module QeaToXmi
+      # Builds MDG technology stereotype definitions as xmi gem model
+      # objects for inclusion in the UML model tree.
+      #
+      # When EA exports a model that references MDG stereotypes, it
+      # includes the stereotype DEFINITIONS in the output — each as
+      # `<packagedElement xmi:type="uml:Stereotype">` with its tagged
+      # values as `<ownedAttribute>` elements, plus an
+      # `<uml:Extension>` linking the stereotype to its base metaclass.
+      #
+      # MDG technologies are registered at runtime via
+      # {Ea::Mdg::Registry} (OCP — swap in/out without code changes).
+      # The ProfileSerializer queries the registry at call time, so
+      # the output reflects whatever MDGs are currently registered.
+      #
+      # Uses the xmi gem's typed models (PackagedElement, OwnedAttribute,
+      # Type) for serialization — no raw XML string building.
+      class ProfileSerializer
+        UML_TYPE_HREF = "http://www.omg.org/spec/UML/20110701/UML.xmi"
+
+        # @param mdg_registry [Ea::Mdg::Registry, nil]
+        def initialize(mdg_registry)
+          @mdg_registry = mdg_registry
+        end
+
+        # @return [Array<Xmi::Uml::PackagedElement>] stereotype and
+        #   extension elements for all registered MDG documents.
+        #   Empty array when no registry or no stereotypes.
+        #
+        # Stereotype ids are the bare names, so two MDGs defining the
+        # same name would emit clashing definitions. The first
+        # document to define a name wins.
+        def call
+          return [] unless @mdg_registry
+
+          @mdg_registry.documents
+                       .flat_map(&:stereotypes)
+                       .uniq(&:name)
+                       .flat_map { |stereo| [build_stereotype(stereo), *build_extensions(stereo)] }
+        end
+
+        private
+
+        # @return [Xmi::Uml::PackagedElement] the uml:Stereotype element
+        def build_stereotype(stereotype)
+          ::Xmi::Uml::PackagedElement.new(
+            type: "uml:Stereotype",
+            id: stereotype.name,
+            name: stereotype.name,
+            owned_attribute: owned_attributes_for(stereotype)
+          )
+        end
+
+        # @return [Array<Xmi::Uml::PackagedElement>] one uml:Extension
+        #   per applies_to metaclass
+        def build_extensions(stereotype)
+          stereotype.applies_to.filter_map do |metaclass|
+            next nil if metaclass.nil? || metaclass.empty?
+
+            build_extension(stereotype, metaclass)
+          end
+        end
+
+        # EA carries both ends as one space-separated memberEnd
+        # attribute on the Extension and repeats it on the
+        # ExtensionEnd — never as child <memberEnd> elements.
+        def build_extension(stereotype, metaclass)
+          base_id = "#{stereotype.name}-base_#{metaclass}"
+          member_ends = "extension_#{stereotype.name} #{base_id}"
+
+          ::Xmi::Uml::PackagedElement.new(
+            type: "uml:Extension",
+            id: "#{metaclass}_#{stereotype.name}",
+            name: "A_#{metaclass}_#{stereotype.name}",
+            member_end: member_ends,
+            owned_end: [build_extension_end(stereotype, member_ends)]
+          )
+        end
+
+        def build_extension_end(stereotype, member_ends)
+          ::Xmi::Uml::OwnedEnd.new(
+            type: "uml:ExtensionEnd",
+            id: "extension_#{stereotype.name}",
+            name: "extension_#{stereotype.name}",
+            member_end: member_ends,
+            is_composite: true,
+            uml_type: ::Xmi::Uml::Type.new(idref: stereotype.name)
+          )
+        end
+
+        # All ownedAttribute elements: base_{metaclass} link(s) + one
+        # per tagged value.
+        def owned_attributes_for(stereotype)
+          attrs = base_properties(stereotype)
+          attrs.concat(tagged_value_properties(stereotype))
+          attrs
+        end
+
+        # @return [Array<Xmi::Uml::OwnedAttribute>] one base_{mc}
+        #   property per applies_to metaclass, linking the stereotype
+        #   to its UML base via the Extension association.
+        def base_properties(stereotype)
+          stereotype.applies_to.filter_map do |metaclass|
+            next nil if metaclass.nil? || metaclass.empty?
+
+            build_base_property(stereotype, metaclass)
+          end
+        end
+
+        def build_base_property(stereotype, metaclass)
+          ::Xmi::Uml::OwnedAttribute.new(
+            type: "uml:Property",
+            id: "#{stereotype.name}-base_#{metaclass}",
+            name: "base_#{metaclass}",
+            association: "#{metaclass}_#{stereotype.name}",
+            uml_type: ::Xmi::Uml::Type.new(href: "#{UML_TYPE_HREF}##{metaclass}")
+          )
+        end
+
+        # @return [Array<Xmi::Uml::OwnedAttribute>] one per tagged value
+        def tagged_value_properties(stereotype)
+          stereotype.tagged_values.map do |tv|
+            build_tagged_value_property(stereotype.name, tv)
+          end
+        end
+
+        def build_tagged_value_property(stereo_name, tagged_value)
+          ::Xmi::Uml::OwnedAttribute.new(
+            type: "uml:Property",
+            id: "#{stereo_name}-#{tagged_value.name}",
+            name: tagged_value.name,
+            uml_type: ::Xmi::Uml::Type.new(href: "#{UML_TYPE_HREF}##{normalize_type(tagged_value.type)}")
+          )
+        end
+
+        # Map MDG tagged value types to UML XMI primitive type names.
+        # Unknown types default to String (matches EA's behaviour).
+        def normalize_type(raw)
+          return "String" if raw.nil? || raw.empty?
+
+          TYPE_MAP.fetch(raw.to_s.downcase, "String")
+        end
+
+        TYPE_MAP = {
+          "boolean" => "Boolean",
+          "integer" => "Integer",
+          "int" => "Integer",
+          "real" => "Real",
+          "double" => "Real",
+          "string" => "String",
+          "enumeration" => "String",
+          "class" => "Class"
+        }.freeze
+      end
+    end
+  end
+end

data/lib/ea/transformers/qea_to_xmi/run_state.rb

@@ -20,8 +20,9 @@ module Ea
       # `Variable` is the attribute name on the classifier (used to
       # resolve the definingFeature EAID at transformation time).
       # The `Value` plus `Op` form the OpaqueExpression body — Sparx
-      # prepends the operator character to the value (`Op==` →
-      # `body="=Value"`).
+      # prepends the stored operator verbatim. Equality is stored as
+      # `Op==;` (parsed op "="), so `body="=Value"`; comparison ops
+      # keep their full text (`Op=<=;` → `body="<=Value"`).
       #
       # The parser is pure: no I/O, no state. Same input always yields
       # the same output array of {Variable, Value, Op} structs.
@@ -32,15 +33,15 @@ module Ea
         # @!attribute value [String] the literal value text
         # @!attribute op [String] the operator character(s) EA stored
         Binding = Struct.new(:variable, :value, :op) do
-          # Sparx serialises the value with the operator character
-          # prepended (`Op==` → `body="=Value"`). For other operators
-          # (`!=`, `<`, `>`) the full operator string is prepended.
+          # Sparx serialises the value with the stored operator
+          # prepended verbatim ("=" for equality, "<=" etc. as-is —
+          # EA's reference exports contain body="<=valueTwo").
           #
           # @return [String] the body to set on the OpaqueExpression
           def body
             return value if op.nil? || op.empty?
 
-            "#{op[0]}#{value}"
+            "#{op}#{value}"
           end
         end