lutaml 0.9.9 → 0.9.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cdc354ae49059f9158e3bfb8d0e7813b6c61d0084fa42ed7071026a9e62d311
-  data.tar.gz: 30c6683d8e22d2e1ded1b8ca53d3d63e5129025049314b036b678efb611f713e
+  metadata.gz: 59f3f41813beaec8f6ffe17b8077aa9ad9d0a1a49861d12075b86e579e4d8287
+  data.tar.gz: f52b06e26ebecc5088248fa0d83696bfae5d26b6b2c31d32bca1d3210db5493d
 SHA512:
-  metadata.gz: 1578a3589e20f92586cf4a60a6585ce5b758262a1112e3e5598e33c3209de72d477bf66b0fefd017e4633bd065ef93ed3fe37e2b55f60aae50a78203f299bcfa
-  data.tar.gz: 72883f24b869448ac32f8724cb05cd5d24acf88ecbaa066bf084724f57ac116567266257f317b0e284e8ab081519eae6d8a2108915fb4e680076990b43339576
+  metadata.gz: f0b91cc8fcf077286165cb879a9896f401ccd45f72db55fb8a2ef0f89aca841f7d57bdf581194f3487f2f8edfc83103c68b174f36f95cdaa4710d2303ac01d64
+  data.tar.gz: e16c5a41385564b5e9c3c89850114daa5e8ff0ae1a0a4bac5ed5f12c40155d4164c087e74b1e80841ab8a5d58af305ab6caa621f93a321f97fe44fa0604960f2

data/lib/lutaml/version.rb

@@ -1,3 +1,3 @@
 module Lutaml
-  VERSION = "0.9.9".freeze
+  VERSION = "0.9.10".freeze
 end

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

@@ -16,13 +16,37 @@ module Lutaml
         }.freeze
         attr_reader :xmi_cache, :xmi_root_model
 
-        # @param xml [String] path to xml
-        # @param options [Hash] options for parsing
-        # @return [Lutaml::Uml::Document]
-        def self.parse(xml, _options = {})
-          xml_content = File.read(xml)
-          xmi_model = Xmi::Sparx::SparxRoot.parse_xml(xml_content)
-          new.parse(xmi_model)
+        class << self
+          # @param xml [String] path to xml
+          # @param options [Hash] options for parsing
+          # @return [Lutaml::Uml::Document]
+          def parse(xml, _options = {})
+            xmi_model = get_xmi_model(xml)
+            new.parse(xmi_model)
+          end
+
+          # @param xml [String] path to xml
+          # @return [Hash]
+          def serialize_xmi(xml)
+            xmi_model = get_xmi_model(xml)
+            new.serialize_xmi(xmi_model)
+          end
+
+          # @param xml [String] path to xml
+          # @param name [String]
+          # @return [Hash]
+          def serialize_generalization_by_name(xml, name)
+            xmi_model = get_xmi_model(xml)
+            new.serialize_generalization_by_name(xmi_model, name)
+          end
+
+          private
+
+          # @param xml [String]
+          # @return [Shale::Mapper]
+          def get_xmi_model(xml)
+            Xmi::Sparx::SparxRoot.parse_xml(File.read(xml))
+          end
         end
 
         # @param xmi_model [Shale::Mapper]
@@ -30,7 +54,27 @@ module Lutaml
         def parse(xmi_model)
           @xmi_cache = {}
           @xmi_root_model = xmi_model
-          ::Lutaml::Uml::Document.new(serialize_to_hash(xmi_model))
+          serialized_hash = serialize_xmi(xmi_model)
+
+          ::Lutaml::Uml::Document.new(serialized_hash)
+        end
+
+        # @param xmi_model [Shale::Mapper]
+        # return [Hash]
+        def serialize_xmi(xmi_model)
+          @xmi_cache = {}
+          @xmi_root_model = xmi_model
+          serialize_to_hash(xmi_model)
+        end
+
+        # @param xmi_model [Shale::Mapper]
+        # @param name [String]
+        # @return [Hash]
+        def serialize_generalization_by_name(xmi_model, name)
+          @xmi_cache = {}
+          @xmi_root_model = xmi_model
+          klass = find_klass_packaged_element_by_name(name)
+          serialize_generalization(klass)
         end
 
         private
@@ -105,6 +149,138 @@ module Lutaml
           end
         end
 
+        # @param klass [Shale::Mapper]
+        # # @return [Hash]
+        def serialize_generalization(klass)
+          general_hash, next_general_node_id = get_top_level_general_hash(klass)
+          return general_hash unless next_general_node_id
+
+          general_hash[:general] = serialize_generalization_attributes(
+            next_general_node_id,
+          )
+
+          general_hash
+        end
+
+        # @param klass [Shale::Mapper]
+        # @return [Array<Hash>]
+        def get_top_level_general_hash(klass) # rubocop:disable Metrics/AbcSize
+          general_hash, next_general_node_id = get_general_hash(klass.id)
+          general_hash[:name] = klass.name
+          general_hash[:type] = klass.type
+          general_hash[:definition] = lookup_general_documentation(klass.id)
+          general_hash[:stereotype] = doc_node_attribute_value(
+            klass.id, "stereotype"
+          )
+
+          # update_inherited_attributes(general_hash)
+          # update_gen_attributes(general_hash)
+
+          [general_hash, next_general_node_id]
+        end
+
+        def lookup_general_documentation(klass_id)
+          # lookup_attribute_documentation(klass_id) ||
+          #   lookup_element_prop_documentation(klass_id)
+
+          lookup_element_prop_documentation(klass_id)
+        end
+
+        def update_gen_attributes(general_hash)
+          general_hash[:gen_attributes] = serialize_gen_attributes
+        end
+
+        def update_inherited_attributes(general_hash)
+          general_hash[:gml_attributes] = serialize_gml_attributes
+          general_hash[:core_attributes] = serialize_core_attributes
+        end
+
+        # @param xmi_id [String]
+        # @param model [Shale::Mapper]
+        # @return [Array<Hash>]
+        # @note get generalization node and its owned attributes
+        def serialize_generalization_attributes(general_id)
+          general_hash, next_general_node_id = get_general_hash(general_id)
+
+          if next_general_node_id
+            general_hash[:general] = serialize_generalization_attributes(
+              next_general_node_id,
+            )
+          end
+
+          general_hash
+        end
+
+        # @param xmi_id [String]
+        # @return [Shale::Mapper]
+        def get_general_node(xmi_id)
+          find_packaged_element_by_id(xmi_id)
+        end
+
+        # @param general_node [Shale::Mapper]
+        # # @return [Hash]
+        def get_general_attributes(general_node)
+          attrs = serialize_class_attributes(general_node, with_assoc: true)
+          attrs.sort_by { |i| i[:name] }
+        end
+
+        # @param general_node [Shale::Mapper]
+        # @return [String]
+        def get_next_general_node_id(general_node)
+          general_node.generalization.first&.general
+        end
+
+        # @param general_id [String]
+        # @return [Array<Hash>]
+        def get_general_hash(general_id)
+          general_node = get_general_node(general_id)
+          general_node_attrs = get_general_attributes(general_node)
+          general_upper_klass = find_upper_level_packaged_element(general_id)
+          next_general_node_id = get_next_general_node_id(general_node)
+
+          [
+            {
+              general_id: general_id,
+              general_name: general_node.name,
+              general_attributes: general_node_attrs,
+              general_upper_klass: general_upper_klass,
+              general: {},
+            },
+            next_general_node_id,
+          ]
+        end
+
+        # @param id [String]
+        # @return [Shale::Mapper]
+        def find_packaged_element_by_id(id)
+          all_packaged_elements.find { |e| e.id == id }
+        end
+
+        # @param id [String]
+        # @return [Shale::Mapper]
+        def find_upper_level_packaged_element(klass_id)
+          upper_klass = all_packaged_elements.find do |e|
+            e.packaged_element.find { |pe| pe.id == klass_id }
+          end
+          upper_klass&.name
+        end
+
+        # @param name [String]
+        # @return [Shale::Mapper]
+        def find_klass_packaged_element_by_name(name)
+          all_packaged_elements.find do |e|
+            e.type?("uml:Class") && e.name == name
+          end
+        end
+
+        # @param name [String]
+        # @return [Shale::Mapper]
+        def find_packaged_element_by_name(name)
+          all_packaged_elements.find do |e|
+            e.name == name
+          end
+        end
+
         # @param package [Shale::Mapper]
         # @return [Array<Hash>]
         # @note xpath ./packagedElement[@xmi:type="uml:Enumeration"]
@@ -226,9 +402,9 @@ module Lutaml
         # @return [Shale::Mapper]
         # @note xpath %(//connector[@xmi:idref="#{link_id}"])
         def fetch_connector(link_id)
-          @xmi_root_model.extension.connectors.connector.select do |con|
+          @xmi_root_model.extension.connectors.connector.find do |con|
             con.idref == link_id
-          end.first
+          end
         end
 
         # @param link_id [String]
@@ -428,9 +604,9 @@ module Lutaml
           all_elements = all_packaged_elements
 
           owned_attributes = all_elements.map(&:owned_attribute).flatten
-          oa = owned_attributes.select do |a|
+          oa = owned_attributes.find do |a|
             !!a.association && a.uml_type && a.uml_type.idref == xmi_id
-          end.first
+          end
 
           if oa
             cardinality = cardinality_min_max_value(
@@ -446,37 +622,104 @@ module Lutaml
         # @return [Shale::Mapper]
         # @note xpath %(//element[@xmi:idref="#{klass['xmi:id']}"])
         def fetch_element(klass_id)
-          @xmi_root_model.extension.elements.element.select do |e|
+          @xmi_root_model.extension.elements.element.find do |e|
             e.idref == klass_id
-          end.first
+          end
         end
 
         # @param klass [Shale::Mapper]
+        # @param with_assoc [Boolean]
         # @return [Array<Hash>]
         # @note xpath .//ownedAttribute[@xmi:type="uml:Property"]
-        def serialize_class_attributes(klass)
+        def serialize_class_attributes(klass, with_assoc: false)
           klass.owned_attribute.select { |attr| attr.type?("uml:Property") }
             .map do |oa|
-            uml_type = oa.uml_type
-            uml_type_idref = uml_type.idref if uml_type
+            if with_assoc || oa.association.nil?
+              attrs = build_class_attributes(oa)
 
-            if oa.association.nil?
-              {
-                id: oa.id,
-                name: oa.name,
-                type: lookup_entity_name(uml_type_idref) || uml_type_idref,
-                xmi_id: uml_type_idref,
-                is_derived: oa.is_derived,
-                cardinality: cardinality_min_max_value(
-                  oa.lower_value&.value,
-                  oa.upper_value&.value,
-                ),
-                definition: lookup_attribute_documentation(oa.id),
-              }
+              if with_assoc && oa.association
+                attrs[:association] = oa.association
+                attrs[:definition] = loopup_assoc_def(oa.association)
+                attrs[:type_ns] = get_ns_by_type(attrs[:type])
+              end
+
+              attrs
             end
           end.compact
         end
 
+        def loopup_assoc_def(association)
+          connector = fetch_connector(association)
+          connector&.documentation&.value
+        end
+
+        # @return [Array<Hash>]
+        def serialize_gml_attributes
+          element = find_packaged_element_by_name("_Feature")
+          attrs = serialize_class_attributes(element, with_assoc: true)
+          attrs.each { |attr| attr[:upper_klass] = "gml" }
+        end
+
+        # @return [Array<Hash>]
+        def serialize_core_attributes
+          element = find_packaged_element_by_name("_CityObject")
+          attrs = serialize_class_attributes(element, with_assoc: false)
+          attrs.each { |attr| attr[:upper_klass] = "core" }
+        end
+
+        # @return [Array<Hash>]
+        def select_gen_attributes
+          element = find_packaged_element_by_name("gen")
+          gen_attr_element = find_packaged_element_by_name("_genericAttribute")
+
+          element.packaged_element.select do |e|
+            e.type?("uml:Class") &&
+              e.generalization&.first&.general == gen_attr_element.id
+          end
+        end
+
+        # @return [Array<Hash>]
+        def serialize_gen_attributes
+          klasses = select_gen_attributes
+
+          klasses.map do |klass|
+            attr = serialize_class_attributes(klass, with_assoc: false)
+            attr.first[:name] = klass.name
+            attr.first[:type] = "gen:#{klass.name}"
+            attr.first[:upper_klass] = "gen"
+            attr
+          end.flatten!
+        end
+
+        # @param type [String]
+        # @return [String]
+        def get_ns_by_type(type)
+          return unless type
+
+          p = find_klass_packaged_element_by_name(type)
+          find_upper_level_packaged_element(p.id)
+        end
+
+        # @param klass_id [String]
+        # @return [Array<Hash>]
+        def build_class_attributes(owned_attr) # rubocop:disable Metrics/MethodLength
+          uml_type = owned_attr.uml_type
+          uml_type_idref = uml_type.idref if uml_type
+
+          {
+            id: owned_attr.id,
+            name: owned_attr.name,
+            type: lookup_entity_name(uml_type_idref) || uml_type_idref,
+            xmi_id: uml_type_idref,
+            is_derived: owned_attr.is_derived,
+            cardinality: cardinality_min_max_value(
+              owned_attr.lower_value&.value,
+              owned_attr.upper_value&.value,
+            ),
+            definition: lookup_attribute_documentation(owned_attr.id),
+          }
+        end
+
         # @param min [String]
         # @param max [String]
         # @return [Hash]
@@ -533,6 +776,18 @@ module Lutaml
           attribute_node&.documentation&.value
         end
 
+        # @param xmi_id [String]
+        # @return [String]
+        def lookup_element_prop_documentation(xmi_id)
+          element_node = @xmi_root_model.extension.elements.element.find do |e|
+            e.idref == xmi_id
+          end
+
+          return unless element_node&.properties
+
+          element_node&.properties&.documentation
+        end
+
         # @param xmi_id [String]
         # @return [String]
         def lookup_entity_name(xmi_id)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-08-12 00:00:00.000000000 Z
+date: 2024-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expressir