ea 0.1.0 → 0.1.4

data/lib/ea/transformers/qea_to_xmi.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformers
+    # Full-fidelity transformer: Ea::Qea::Database → Sparx XMI.
+    #
+    # Walks the package tree starting at root packages, building
+    # Xmi::Sparx::Root / Xmi::Uml::UmlModel / Xmi::Uml::PackagedElement
+    # models from each QEA row, then asks the xmi gem to serialize them
+    # via `to_xml(use_prefix: true)` to produce Sparx XMI in the canonical
+    # mixed-prefix style.
+    #
+    # Use this for Sparx-to-Sparx round-trip — no intermediate
+    # Lutaml::Uml::Document, no loss of Sparx-specific concepts
+    # (multiplicities, tagged values, stereotypes, primitive types,
+    # instance specifications, association ends). For a tool-agnostic
+    # UML document → XMI path, use UmlToXmi.
+    module QeaToXmi
+      autoload :Transformer,    "ea/transformers/qea_to_xmi/transformer"
+      autoload :Context,        "ea/transformers/qea_to_xmi/context"
+      autoload :IdAllocator,    "ea/transformers/qea_to_xmi/id_allocator"
+      autoload :GuidFormat,     "ea/transformers/qea_to_xmi/guid_format"
+      autoload :Cardinality,    "ea/transformers/qea_to_xmi/cardinality"
+      autoload :Visibility,     "ea/transformers/qea_to_xmi/visibility"
+      autoload :RunState,       "ea/transformers/qea_to_xmi/run_state"
+      autoload :AssociationEnd, "ea/transformers/qea_to_xmi/association_end"
+    end
+  end
+end

data/lib/ea/transformers/uml_to_xmi/id_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformers
+    module UmlToXmi
+      # Allocates xmi:id values for UML elements during lossy serialization.
+      #
+      # Strategy:
+      #   1. If the element already has an `xmi_id` (set by the QEA factory
+      #      during parsing), reuse it.
+      #   2. Otherwise synthesize a stable `EAID_…` from a counter.
+      #
+      # This class is used only by the lossy {UmlToXmi::Transformer} path.
+      # The full-fidelity {QeaToXmi} path uses {QeaToXmi::GuidFormat} to
+      # normalize raw EA GUIDs.
+      class IdGenerator
+        PREFIX = "EAID"
+        MODEL_ID = "#{PREFIX}_EA_MODEL"
+
+        def initialize
+          @assigned = {} # object_id → xmi:id
+          @counter = 0
+        end
+
+        def eaid_for(element)
+          key = element.object_id
+          @assigned[key] ||= begin
+            @counter += 1
+            extract_id(element) || synthesize(@counter)
+          end
+        end
+
+        def model_id
+          MODEL_ID
+        end
+
+        private
+
+        # `Lutaml::Uml::Value` exposes its XMI identifier via `id` (it does
+        # not inherit from TopElement, so it has no `xmi_id`). All other
+        # serializable UML types use `xmi_id`.
+        def extract_id(element)
+          return element.id if element.is_a?(Lutaml::Uml::Value)
+
+          element.xmi_id
+        end
+
+        def synthesize(n)
+          format("%<prefix>s_%<hex>08X", prefix: PREFIX, hex: n)
+        end
+      end
+    end
+  end
+end

data/lib/ea/transformers/uml_to_xmi/transformer.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformers
+    module UmlToXmi
+      # Orchestrates transformation of a {Lutaml::Uml::Document} to Sparx XMI.
+      #
+      # Walks the UML tree (packages → classifiers → features) and emits XML
+      # via {Writer}. Each UML element type has its own private emitter method.
+      #
+      # This is the LOSSY path — Sparx-specific concepts (stereotypes,
+      # multiplicities, tagged values, EA extension block) are not modeled in
+      # Lutaml::Uml and therefore not emitted. For Sparx-to-Sparx round-trip
+      # with full fidelity, use {Ea::Transformers::QeaToXmi}.
+      class Transformer
+        MODEL_NAME = "EA_Model"
+
+        def initialize(document)
+          @document = document
+          @id_gen = IdGenerator.new
+          @writer = Writer.new
+        end
+
+        # @return [String] XMI XML document
+        def serialize
+          assign_ids!
+          @writer.xmi_root do
+            @writer.documentation
+            @writer.uml_model(@id_gen.model_id, MODEL_NAME) do
+              emit_top_level
+            end
+          end
+          @writer.to_xml
+        end
+
+        private
+
+        def assign_ids!
+          walk_all(@document.packages)
+          walk_all(@document.classes)
+          walk_all(@document.enums)
+          walk_all(@document.data_types)
+        end
+
+        def walk_all(elements)
+          elements.each { |e| register!(e) }
+        end
+
+        def register!(element)
+          @id_gen.eaid_for(element)
+          case element
+          when Lutaml::Uml::Package then register_package!(element)
+          when Lutaml::Uml::UmlClass then register_class!(element)
+          end
+        end
+
+        def register_package!(pkg)
+          walk_all(pkg.packages)
+          walk_all(pkg.classes)
+          walk_all(pkg.enums)
+          walk_all(pkg.data_types)
+        end
+
+        def register_class!(klass)
+          klass.attributes.each { |a| @id_gen.eaid_for(a) }
+          klass.operations.each { |o| @id_gen.eaid_for(o) }
+        end
+
+        def emit_top_level
+          @document.packages.each   { |p| emit_package(@writer, p) }
+          @document.classes.each    { |c| emit_class(@writer, c) }
+          @document.enums.each      { |e| emit_enum(@writer, e) }
+          @document.data_types.each { |d| emit_data_type(@writer, d) }
+        end
+
+        def emit_package(w, pkg)
+          w.packaged_element("uml:Package", @id_gen.eaid_for(pkg), pkg.name) do
+            pkg.packages.each   { |p| emit_package(w, p) }
+            pkg.classes.each    { |c| emit_class(w, c) }
+            pkg.enums.each      { |e| emit_enum(w, e) }
+            pkg.data_types.each { |d| emit_data_type(w, d) }
+          end
+        end
+
+        def emit_class(w, klass)
+          w.packaged_element(
+            "uml:Class",
+            @id_gen.eaid_for(klass),
+            klass.name,
+            is_abstract: klass.is_abstract,
+          ) do
+            klass.attributes.each { |a| emit_attribute(w, a) }
+            klass.operations.each { |o| emit_operation(w, o) }
+          end
+        end
+
+        def emit_enum(w, enum)
+          w.packaged_element(
+            "uml:Enumeration",
+            @id_gen.eaid_for(enum),
+            enum.name,
+          ) do
+            (enum.values || []).each { |v| emit_literal(w, v) }
+          end
+        end
+
+        def emit_data_type(w, data_type)
+          w.packaged_element(
+            "uml:DataType",
+            @id_gen.eaid_for(data_type),
+            data_type.name,
+          ) do
+            data_type.attributes.each { |a| emit_attribute(w, a) }
+            data_type.operations.each { |o| emit_operation(w, o) }
+          end
+        end
+
+        def emit_attribute(w, attr)
+          type_ref = type_reference(attr.type)
+          w.owned_attribute(@id_gen.eaid_for(attr), attr.name, type: type_ref) do
+            # Multiplicity / defaults not modeled in Lutaml::Uml; deferred.
+          end
+        end
+
+        def emit_operation(w, op)
+          w.owned_operation(@id_gen.eaid_for(op), op.name)
+        end
+
+        def emit_literal(w, literal)
+          case literal
+          when Lutaml::Uml::Value
+            w.owned_literal(@id_gen.eaid_for(literal), literal.name)
+          when String
+            w.owned_literal(synthesize_literal_id(literal), literal)
+          else
+            w.owned_literal(synthesize_literal_id(literal.to_s), literal.to_s)
+          end
+        end
+
+        def type_reference(type_name)
+          return nil if type_name.nil? || type_name.empty?
+
+          type_name
+        end
+
+        def synthesize_literal_id(name)
+          format("EAID_LIT_%<hex>08X", hex: name.to_s.bytes.sum)
+        end
+      end
+    end
+  end
+end

data/lib/ea/transformers/uml_to_xmi/writer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Transformers
+    module UmlToXmi
+      # Low-level XML structural primitives for emitting Sparx-flavored XMI.
+      #
+      # This class has no UML domain knowledge — it only knows the XML shapes
+      # (XMI root, uml:Model, packagedElement, ownedAttribute, …) required to
+      # produce a well-formed Sparx XMI document. {Transformer} drives it.
+      class Writer
+        XMI_NS = "http://www.omg.org/spec/XMI/20131001"
+        UML_NS = "http://www.omg.org/spec/UML/20161101"
+
+        attr_reader :builder
+
+        def initialize
+          @builder = Nokogiri::XML::Builder.new(encoding: "UTF-8")
+        end
+
+        def xmi_root
+          @builder["xmi"].XMI(root_attributes) { yield self }
+        end
+
+        def documentation(exporter: "ea-rb", exporter_version: Ea::VERSION)
+          @builder["xmi"].Documentation(
+            exporter: exporter,
+            exporterVersion: exporter_version,
+          )
+        end
+
+        def uml_model(id, name)
+          @builder["uml"].Model(
+            "xmi:type": "uml:Model",
+            "xmi:id": id,
+            name: name,
+          ) { yield self }
+        end
+
+        def packaged_element(uml_type, id, name, **attrs)
+          @builder.packagedElement(packaged_attrs(uml_type, id, name, attrs)) do
+            yield self if block_given?
+          end
+        end
+
+        def owned_attribute(id, name, type: nil, visibility: "public")
+          attrs = { "xmi:type": "uml:Property", "xmi:id": id, name: name,
+                    visibility: visibility }
+          attrs[:type] = type if type
+          @builder.ownedAttribute(attrs) { yield self if block_given? }
+        end
+
+        def owned_operation(id, name, visibility: "public")
+          @builder.ownedOperation(
+            "xmi:type": "uml:Operation", "xmi:id": id, name: name,
+            visibility: visibility,
+          ) { yield self if block_given? }
+        end
+
+        def owned_literal(id, name)
+          @builder.ownedLiteral(
+            "xmi:type": "uml:EnumerationLiteral", "xmi:id": id, name: name,
+          )
+        end
+
+        def generalization(id, general_id)
+          @builder.generalization(
+            "xmi:type": "uml:Generalization",
+            "xmi:id": id,
+            general: general_id,
+          )
+        end
+
+        def to_xml
+          @builder.doc.to_xml
+        end
+
+        private
+
+        def root_attributes
+          { "xmlns:xmi": XMI_NS, "xmlns:uml": UML_NS }
+        end
+
+        def packaged_attrs(uml_type, id, name, attrs)
+          result = { "xmi:type": uml_type, "xmi:id": id }
+          result[:name] = name if name
+          result[:"isAbstract"] = "true" if attrs[:is_abstract]
+          result[:visibility] = attrs[:visibility] if attrs[:visibility]
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ea/transformers/uml_to_xmi.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformers
+    # Lossy transformer: Lutaml::Uml::Document → Sparx XMI.
+    #
+    # Use this when the source is a tool-agnostic UML model (from LML,
+    # MagicDraw, Papyrus, etc.) and some information loss is acceptable.
+    # For Sparx QEA → Sparx XMI, use {Ea::Transformers::QeaToXmi} instead.
+    module UmlToXmi
+      autoload :Transformer, "ea/transformers/uml_to_xmi/transformer"
+      autoload :Writer,      "ea/transformers/uml_to_xmi/writer"
+      autoload :IdGenerator, "ea/transformers/uml_to_xmi/id_generator"
+    end
+  end
+end

data/lib/ea/transformers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  # Output transformers — converts domain models to interchange formats.
+  #
+  # Two entry points:
+  #
+  #   {uml_to_xmi} — lossy, takes a Lutaml::Uml::Document (cross-tool use)
+  #   {qea_to_xmi} — full fidelity, takes an Ea::Qea::Database
+  #                  (Sparx-to-Sparx round-trip)
+  module Transformers
+    autoload :UmlToXmi, "ea/transformers/uml_to_xmi"
+    autoload :QeaToXmi, "ea/transformers/qea_to_xmi"
+
+    class << self
+      # Lossy: any Lutaml::Uml::Document → Sparx XMI (cross-tool).
+      # @param document [Lutaml::Uml::Document]
+      # @return [String] XMI XML
+      def uml_to_xmi(document)
+        UmlToXmi::Transformer.new(document).serialize
+      end
+
+      # Full fidelity: Ea::Qea::Database → Sparx XMI.
+      # Walks the QEA tables directly — no intermediate UML model, no loss of
+      # Sparx-specific concepts (stereotypes, tagged values, multiplicities,
+      # diagrams, xrefs).
+      # @param database [Ea::Qea::Database]
+      # @return [String] XMI XML
+      def qea_to_xmi(database)
+        QeaToXmi::Transformer.new(database).serialize
+      end
+    end
+  end
+end

data/lib/ea/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ea
-  VERSION = "0.1.0"
+  VERSION = "0.1.4"
 end

data/lib/ea/xmi/liquid_drops/association_drop.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class AssociationDrop < Liquid::Drop
+        def initialize(association, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = association
+          @options = options
+          @lookup = options[:lookup]
+        end
+
+        def xmi_id
+          @model.xmi_id
+        end
+
+        def member_end
+          @model.member_end
+        end
+
+        def member_end_type
+          @model.member_end_type
+        end
+
+        def member_end_cardinality
+          ::Ea::Xmi::LiquidDrops::CardinalityDrop.new(@model.member_end_cardinality)
+        end
+
+        def member_end_attribute_name
+          @model.member_end_attribute_name
+        end
+
+        def member_end_xmi_id
+          @model.member_end_xmi_id
+        end
+
+        def owner_end
+          @model.owner_end
+        end
+
+        def owner_end_xmi_id
+          @model.owner_end_xmi_id
+        end
+
+        def definition
+          @model.definition
+        end
+
+        def connector
+          connector = @lookup.fetch_connector(@model.xmi_id)
+          ::Ea::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
+        end
+      end
+    end
+  end
+end

data/lib/ea/xmi/liquid_drops/attribute_drop.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class AttributeDrop < Liquid::Drop
+        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = model
+          @options = options
+          @lookup = options[:lookup]
+        end
+
+        def id
+          @model.id
+        end
+
+        def name
+          @model.name
+        end
+
+        def type
+          @model.type
+        end
+
+        def xmi_id
+          @model.xmi_id
+        end
+
+        def is_derived # rubocop:disable Naming/PredicateName,Naming/PredicatePrefix
+          @model.is_derived
+        end
+
+        def cardinality
+          ::Ea::Xmi::LiquidDrops::CardinalityDrop.new(@model.cardinality)
+        end
+
+        def definition
+          if @options[:with_assoc] && @model.association
+            @lookup.loopup_assoc_def(@model.association)
+          else
+            @model.definition
+          end
+        end
+
+        def association
+          if @options[:with_assoc] && @model.association
+            @model.association
+          end
+        end
+
+        def association_connector
+          return unless @model.association
+
+          connector = @lookup.fetch_connector(@model.association)
+          if connector
+            ::Ea::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
+          end
+        end
+
+        def type_ns
+          if @options[:with_assoc] && @model.association
+            @model.type_ns
+          end
+        end
+
+        def stereotype
+          @lookup.doc_node_attribute_value(@model.xmi_id, "stereotype")
+        end
+      end
+    end
+  end
+end

data/lib/ea/xmi/liquid_drops/cardinality_drop.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class CardinalityDrop < Liquid::Drop
+        def initialize(model) # rubocop:disable Lint/MissingSuper
+          @model = model
+        end
+
+        def min
+          return nil unless @model
+
+          case @model
+          when ::Lutaml::Uml::Cardinality
+            @model.min
+          else
+            @model.lower_value&.value
+          end
+        end
+
+        def max
+          return nil unless @model
+
+          case @model
+          when ::Lutaml::Uml::Cardinality
+            @model.max
+          else
+            @model.upper_value&.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/xmi/liquid_drops/connector_drop.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class ConnectorDrop < Liquid::Drop
+        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = model
+          @options = options
+          @id_name_mapping = options[:id_name_mapping]
+        end
+
+        def idref
+          @model.idref
+        end
+
+        def name
+          @model.name
+        end
+
+        def type
+          @model&.properties&.ea_type
+        end
+
+        def documentation
+          @model&.documentation&.value
+        end
+
+        def ea_type
+          @model&.properties&.ea_type
+        end
+
+        def direction
+          @model&.properties&.direction
+        end
+
+        def source
+          ::Ea::Xmi::LiquidDrops::SourceTargetDrop.new(@model.source,
+                                                           @options)
+        end
+
+        def target
+          ::Ea::Xmi::LiquidDrops::SourceTargetDrop.new(@model.target,
+                                                           @options)
+        end
+
+        def recognized?
+          !!@id_name_mapping[@model.source.idref] &&
+            !!@id_name_mapping[@model.target.idref]
+        end
+      end
+    end
+  end
+end

data/lib/ea/xmi/liquid_drops/constraint_drop.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class ConstraintDrop < Liquid::Drop
+        def initialize(model) # rubocop:disable Lint/MissingSuper
+          @model = model
+        end
+
+        def name
+          @model.name
+        end
+
+        def type
+          @model.type
+        end
+
+        def weight
+          @model.weight
+        end
+
+        def status
+          @model.status
+        end
+      end
+    end
+  end
+end