lutaml 0.10.4 → 0.10.6

data/lib/lutaml/xmi/parsers/xmi_class_members.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xmi
+    module Parsers
+      module XmiBase
+        # Class member (attribute, operation, constraint) helpers
+        # used by XmiLookupService and Pipeline C (XmiToUml)
+
+        # @param klass_id [String]
+        # @return [Lutaml::Model::Serializable]
+        # @note xpath %(//element[@xmi:idref="#{klass_id}"])
+        def fetch_element(klass_id)
+          xmi_index.find_element(klass_id)
+        end
+
+        def loopup_assoc_def(association)
+          connector = fetch_connector(association)
+          connector&.documentation&.value
+        end
+
+        # @param xmi_id [String]
+        # @return [String]
+        def get_ns_by_xmi_id(xmi_id)
+          return unless xmi_id
+
+          p = find_packaged_element_by_id(xmi_id)
+          return unless p
+
+          find_upper_level_packaged_element(p.id)&.name
+        end
+
+        # @param min [String]
+        # @param max [String]
+        # @return [Hash]
+        def cardinality_min_max_value(min, max)
+          {
+            min: min,
+            max: max,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/parsers/xmi_connector.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xmi
+    module Parsers
+      module XmiBase
+        # Association/connector serialization helpers used by Pipeline C
+
+        # @param link_id [String]
+        # @return [Lutaml::Model::Serializable]
+        # @note xpath %(//connector[@xmi:idref="#{link_id}"])
+        def fetch_connector(link_id)
+          xmi_index.find_connector(link_id)
+        end
+
+        # @param link_id [String]
+        # @param node_name [String] source or target
+        # @return [String]
+        # @note xpath
+        #   %(//connector[@xmi:idref="#{link_id}"]/#{node_name}/documentation)
+        def fetch_definition_node_value(link_id, node_name)
+          connector_node = fetch_connector(link_id)
+          return nil unless connector_node
+
+          node = connector_node.send(node_name.to_sym)
+          return nil unless node
+
+          documentation = node.documentation
+
+          if documentation.is_a?(::Xmi::Sparx::Element::Documentation)
+            documentation&.value
+          else
+            documentation
+          end
+        end
+
+        # @param owner_xmi_id [String]
+        # @param link [Lutaml::Model::Serializable]
+        # @param link_member_name [String]
+        # @return [String]
+        def serialize_owned_type(owner_xmi_id, link, linke_owner_name)
+          case link
+          when ::Xmi::Sparx::Element::NoteLink
+            return
+          when ::Xmi::Sparx::Element::Generalization
+            owner_end, _owner_end_type, _owner_xmi_id =
+              generalization_association(owner_xmi_id, link)
+            return owner_end
+          end
+
+          xmi_id = link.send(linke_owner_name.to_sym)
+          lookup_entity_name(xmi_id) || connector_source_name(xmi_id)
+        end
+
+        # @param owner_xmi_id [String]
+        # @param link [Lutaml::Model::Serializable]
+        # @return [Array<String, String>]
+        def serialize_member_end(owner_xmi_id, link) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+          case link.name
+          when "NoteLink"
+            return
+          when "Generalization"
+            return generalization_association(owner_xmi_id, link)
+          end
+
+          xmi_id = link.start
+          source_or_target = :source
+
+          if link.start == owner_xmi_id
+            xmi_id = link.end
+            source_or_target = :target
+          end
+
+          connector = fetch_connector(link.id)
+          ea_type = connector&.properties&.ea_type
+          member_end_type = ea_type&.downcase
+
+          member_end = member_end_name(xmi_id, source_or_target, link)
+          [member_end, member_end_type, xmi_id]
+        end
+
+        # @param xmi_id [String]
+        # @param source_or_target [Symbol]
+        # @return [String]
+        def member_end_name(xmi_id, source_or_target, link) # rubocop:disable Metrics/MethodLength
+          connector_label = connector_labels(xmi_id, source_or_target)
+          entity_name = lookup_entity_name(xmi_id)
+          connector_name = connector_name_by_source_or_target(
+            xmi_id, source_or_target
+          )
+
+          case link
+          when ::Xmi::Sparx::Element::Aggregation
+            connector_label || entity_name || connector_name
+          else
+            entity_name || connector_name
+          end
+        end
+
+        # @param owner_xmi_id [String]
+        # @param link [Lutaml::Model::Serializable]
+        # @param link_member_name [String]
+        # @return [Array<String, String, Hash, String, String>]
+        def serialize_member_type(owner_xmi_id, link, link_member_name) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+          member_end, member_end_type, xmi_id =
+            serialize_member_end(owner_xmi_id, link)
+
+          if link.is_a?(::Xmi::Sparx::Element::Association)
+            connector_type = link_member_name == "start" ? "source" : "target"
+            member_end_cardinality, member_end_attribute_name =
+              fetch_assoc_connector(link.id, connector_type)
+          else
+            member_end_cardinality, member_end_attribute_name =
+              fetch_owned_attribute_node(xmi_id)
+          end
+
+          if fetch_connector_name(link.id)
+            member_end = fetch_connector_name(link.id)
+          end
+
+          [member_end, member_end_type, member_end_cardinality,
+           member_end_attribute_name, xmi_id]
+        end
+
+        def fetch_connector_name(link_id)
+          connector = fetch_connector(link_id)
+          connector&.name
+        end
+
+        # @param link_id [String]
+        # @param connector_type [String]
+        # @return [Array<Hash, String>]
+        # @note xpath %(//connector[@xmi:idref="#{link_id}"]/#{connector_type})
+        def fetch_assoc_connector(link_id, connector_type) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          connector = fetch_connector(link_id)
+          return [nil, nil] unless connector
+
+          assoc_connector = connector.send(connector_type.to_sym)
+
+          if assoc_connector
+            assoc_connector_type = assoc_connector.type
+            if assoc_connector_type&.multiplicity
+              cardinality = assoc_connector_type.multiplicity.split("..")
+              cardinality.unshift("1") if cardinality.length == 1
+              min, max = cardinality
+            end
+
+            assoc_connector_role = assoc_connector.role
+            attribute_name = assoc_connector.model.name if assoc_connector_role
+            cardinality = cardinality_min_max_value(min, max)
+          end
+
+          [cardinality, attribute_name]
+        end
+
+        # @param owner_xmi_id [String]
+        # @param link [Lutaml::Model::Serializable]
+        # @return [Array<String, String, Hash, String, String>]
+        # @note match return value of serialize_member_type
+        def generalization_association(owner_xmi_id, link) # rubocop:disable Metrics/MethodLength
+          member_end_type = "generalization"
+          xmi_id = link.start
+          source_or_target = :source
+
+          if link.start == owner_xmi_id
+            member_end_type = "inheritance"
+            xmi_id = link.end
+            source_or_target = :target
+          end
+
+          member_end = member_end_name(xmi_id, source_or_target, link)
+
+          [member_end, member_end_type, xmi_id]
+        end
+
+        # Multiple items if search type is idref.  Should search association?
+        # @param xmi_id [String]
+        # @return [Array<Hash, String>]
+        # @note xpath
+        #   %(//ownedAttribute[@association]/type[@xmi:id ref="#{xmi_id}"])
+        def fetch_owned_attribute_node(xmi_id)
+          oa = xmi_index.find_owned_attrs_by_type(xmi_id)
+            .find { |a| !!a.association }
+
+          if oa
+            cardinality = cardinality_min_max_value(
+              oa.lower_value&.value, oa.upper_value&.value
+            )
+            oa_name = oa.name
+          end
+
+          [cardinality, oa_name]
+        end
+
+        # @param xmi_id [String]
+        # @param source_or_target [String]
+        # @return [String]
+        def connector_node_by_id(xmi_id, source_or_target)
+          connector_lookup[[source_or_target.to_sym, xmi_id]]
+        end
+
+        # Lazy-built hash index for O(1) connector lookups
+        # @return [Hash] Mapping of [direction, idref] => connector
+        def connector_lookup
+          @connector_lookup ||= begin
+            lookup = {}
+            connectors = @xmi_root_model.extension&.connectors&.connector || []
+            connectors.each do |con|
+              %i[source target].each do |dir|
+                idref = con.send(dir)&.idref
+                lookup[[dir, idref]] = con if idref
+              end
+            end
+            lookup
+          end
+        end
+
+        # @param xmi_id [String]
+        # @param source_or_target [String]
+        # @return [String]
+        def connector_name_by_source_or_target(xmi_id, source_or_target) # rubocop:disable Metrics/AbcSize
+          node = connector_node_by_id(xmi_id, source_or_target)
+          return node.name if node&.name
+
+          return if node.nil? ||
+            node.send(source_or_target.to_sym).nil? ||
+            node.send(source_or_target.to_sym).model.nil?
+
+          node.send(source_or_target.to_sym).model.name
+        end
+
+        # @param xmi_id [String]
+        # @param source_or_target [String]
+        # @return [String]
+        def connector_labels(xmi_id, source_or_target)
+          node = connector_node_by_id(xmi_id, source_or_target)
+          return if node.nil?
+
+          node.labels&.rt || node.labels&.lt
+        end
+
+        # @param xmi_id [String]
+        # @return [String]
+        # @note xpath %(//source[@xmi:idref="#{xmi_id}"]/model)
+        def connector_source_name(xmi_id)
+          connector_name_by_source_or_target(xmi_id, :source)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/parsers/xml.rb

@@ -4,6 +4,7 @@ require "nokogiri"
 require "htmlentities"
 require "xmi"
 require_relative "xmi_base"
+require_relative "../xmi_lookup_service"
 require "lutaml/converter/xmi_to_uml"
 
 module Lutaml
@@ -13,11 +14,7 @@ module Lutaml
       class Xml
         include Lutaml::Converter::XmiToUml
 
-        @id_name_mapping_static = {}
-        @xmi_root_model_cache_static = {}
-
-        attr_reader :id_name_mapping, :xmi_root_model,
-                    :all_packaged_elements_cache
+        attr_reader :id_name_mapping, :xmi_root_model
 
         include XmiBase
 
@@ -30,69 +27,12 @@ module Lutaml
             new.parse(xmi_model)
           end
 
-          # @param xml [String] path to xml
-          # @param with_gen [Boolean]
-          # @return [Hash]
-          def serialize_xmi(xml, with_gen: false)
-            xmi_model = get_xmi_model(xml)
-            new.serialize_xmi(xmi_model, with_gen: with_gen)
-          end
-
           # @param xml [String] path to xml
           # @return [Liquid::Drop]
           def serialize_xmi_to_liquid(xml, guidance = nil)
             xmi_model = get_xmi_model(xml)
             new.serialize_xmi_to_liquid(xmi_model, guidance)
           end
-
-          # @param xmi_path [String] path to xml
-          # @param name [String]
-          # @param guidance [String]
-          # @return [Hash]
-          def serialize_generalization_by_name( # rubocop:disable Metrics/MethodLength
-            xmi_path, name, guidance = nil
-          )
-            # Load from cache or file
-            xml_cache_key = (Digest::SHA256.file xmi_path).hexdigest
-            xmi_model = @xmi_root_model_cache_static[xml_cache_key] ||
-              get_xmi_model(xmi_path)
-            id_name_mapping = @id_name_mapping_static[xml_cache_key]
-
-            instance = new
-            ret_val = instance.serialize_generalization_by_name(
-              xmi_model, name, guidance, id_name_mapping
-            )
-
-            # Put xmi_model and id_name_mapping to cache
-            @id_name_mapping_static[xml_cache_key] ||= instance.id_name_mapping
-            @xmi_root_model_cache_static[xml_cache_key] ||= xmi_model
-
-            ret_val
-          end
-
-          # @param xmi_path [String] path to xml
-          # @param name [String]
-          # @return [Hash]
-          def serialize_enumeration_by_name( # rubocop:disable Metrics/MethodLength
-            xmi_path, name
-          )
-            # Load from cache or file
-            xml_cache_key = (Digest::SHA256.file xmi_path).hexdigest
-            xmi_model = @xmi_root_model_cache_static[xml_cache_key] ||
-              get_xmi_model(xmi_path)
-            id_name_mapping = @id_name_mapping_static[xml_cache_key]
-
-            instance = new
-            enum = instance.serialize_enumeration_by_name(
-              xmi_model, name, id_name_mapping
-            )
-
-            # Put xmi_model and id_name_mapping to cache
-            @id_name_mapping_static[xml_cache_key] ||= instance.id_name_mapping
-            @xmi_root_model_cache_static[xml_cache_key] ||= xmi_model
-
-            enum
-          end
         end
 
         # @param xmi_model [Lutaml::Model::Serializable]
@@ -102,75 +42,22 @@ module Lutaml
           create_uml_document(xmi_model)
         end
 
-        # @param xmi_model [Lutaml::Model::Serializable]
-        # @param with_gen: [Boolean]
-        # @param with_absolute_path: [Boolean]
-        # return [Hash]
-        def serialize_xmi(xmi_model, with_gen: false, with_absolute_path: false)
-          set_xmi_model(xmi_model)
-          serialize_to_hash(
-            xmi_model,
-            with_gen: with_gen,
-            with_absolute_path: with_absolute_path,
-          )
-        end
-
         # @param xmi_model [Lutaml::Model::Serializable]
         # @param guidance_yaml [String]
         # return [Liquid::Drop]
         def serialize_xmi_to_liquid(xmi_model, guidance = nil)
           set_xmi_model(xmi_model)
-          model = xmi_model.model
-          options = {
-            xmi_root_model: @xmi_root_model,
-            id_name_mapping: @id_name_mapping,
-            with_gen: true,
-            with_absolute_path: true,
-          }
-          ::Lutaml::Xmi::LiquidDrops::RootDrop.new(model, guidance, options)
-        end
-
-        # @param xmi_model [Lutaml::Model::Serializable]
-        # @param name [String]
-        # @param guidance_yaml [String]
-        # @param id_name_mapping [Hash]
-        # @return [Hash]
-        def serialize_generalization_by_name( # rubocop:disable Metrics/MethodLength
-          xmi_model, name, guidance = nil, id_name_mapping = nil
-        )
-          set_xmi_model(xmi_model, id_name_mapping)
-          klass = find_klass_packaged_element(name)
-          options = {
-            xmi_root_model: @xmi_root_model,
-            id_name_mapping: @id_name_mapping,
-            with_gen: true,
-            with_absolute_path: true,
-          }
-          puts "Error: Class not found for name: #{name}!" if klass.nil?
-          ::Lutaml::Xmi::LiquidDrops::KlassDrop.new(
-            klass,
-            guidance,
-            options,
-          )
-        end
-
-        # @param xmi_model [Lutaml::Model::Serializable]
-        # @param name [String]
-        # @param id_name_mapping [Hash]
-        # @return [Hash]
-        def serialize_enumeration_by_name( # rubocop:disable Metrics/MethodLength
-          xmi_model, name, id_name_mapping = nil
-        )
-          set_xmi_model(xmi_model, id_name_mapping)
-          enum = find_enum_packaged_element_by_name(name)
+          uml_document = create_uml_document(xmi_model)
+          lookup = XmiLookupService.new(@xmi_root_model, @id_name_mapping)
           options = {
             xmi_root_model: @xmi_root_model,
             id_name_mapping: @id_name_mapping,
+            lookup: lookup,
             with_gen: true,
             with_absolute_path: true,
           }
-          puts "Error: Enumeration not found for name: #{name}!" if enum.nil?
-          ::Lutaml::Xmi::LiquidDrops::EnumDrop.new(enum, options)
+          ::Lutaml::Xmi::LiquidDrops::RootDrop.new(uml_document, guidance,
+                                                   options)
         end
       end
     end

data/lib/lutaml/xmi/xmi_lookup_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "parsers/xmi_base"
+
+module Lutaml
+  module Xmi
+    # Single bridge between Liquid Drop classes and the XMI document tree.
+    # Drops receive an instance of this service instead of including XmiBase directly.
+    class XmiLookupService
+      include Parsers::XmiBase
+
+      def initialize(xmi_root_model, id_name_mapping)
+        @xmi_root_model = xmi_root_model
+        @id_name_mapping = id_name_mapping
+      end
+
+      # XmiBase methods are private by default; expose as public API for Drops
+      public :doc_node_attribute_value,
+             :lookup_entity_name,
+             :lookup_attribute_documentation,
+             :find_upper_level_packaged_element,
+             :find_packaged_element_by_id,
+             :get_ns_by_xmi_id,
+             :loopup_assoc_def,
+             :fetch_connector,
+             :fetch_definition_node_value,
+             :select_dependencies_by_supplier,
+             :select_dependencies_by_client,
+             :select_all_packaged_elements,
+             :find_subtype_of_from_generalization,
+             :find_subtype_of_from_owned_attribute_type,
+             :get_package_name,
+             :xmi_index
+
+      # Convenience: find extension element by XMI id (used by Drops for
+      # dependency/inheritance lookups)
+      def find_matched_element(xmi_id)
+        xmi_index&.find_element(xmi_id)
+      end
+    end
+  end
+end

data/lib/lutaml.rb

@@ -16,4 +16,3 @@ require_relative "lutaml/uml_repository"
 require_relative "lutaml/xmi"
 require_relative "lutaml/xml"
 require_relative "lutaml/qea"
-# require_relative "lutaml/sysml"