lutaml 0.9.9 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cdc354ae49059f9158e3bfb8d0e7813b6c61d0084fa42ed7071026a9e62d311
-  data.tar.gz: 30c6683d8e22d2e1ded1b8ca53d3d63e5129025049314b036b678efb611f713e
+  metadata.gz: 9de4708a54b2e1e0cd6994dc7931e56711d2e257d1077f96003c4f8de6260c7e
+  data.tar.gz: 461a1f380240be81347038fac000ab836067599ac3485ed7d9e5ba61594f379f
 SHA512:
-  metadata.gz: 1578a3589e20f92586cf4a60a6585ce5b758262a1112e3e5598e33c3209de72d477bf66b0fefd017e4633bd065ef93ed3fe37e2b55f60aae50a78203f299bcfa
-  data.tar.gz: 72883f24b869448ac32f8724cb05cd5d24acf88ecbaa066bf084724f57ac116567266257f317b0e284e8ab081519eae6d8a2108915fb4e680076990b43339576
+  metadata.gz: 40e3e939f49e84407257d9d80cebe83e42ef74ba87d5763f5f0c245d445b857273bce8576f24948a4e0e836fa6df2a6f15980c7add173176910a3180da5b4477
+  data.tar.gz: 0c0c19132496f42ee08b6f9773d1807be9df6f4a3ada9ac49a3d846ee612742db086ca7e15494afbfee601f6ca6571ea532a28a2758f61c7576ba255602718ef

data/lib/lutaml/version.rb

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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class AssociationDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      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
+        ::Lutaml::XMI::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
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class AttributeDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      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
+        @model[:is_derived]
+      end
+
+      def cardinality
+        ::Lutaml::XMI::CardinalityDrop.new(@model[:cardinality])
+      end
+
+      def definition
+        @model[:definition]
+      end
+
+      def association
+        @model[:association]
+      end
+
+      def type_ns
+        @model[:type_ns]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class CardinalityDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def min
+        @model["min"]
+      end
+
+      def max
+        @model["max"]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    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

data/lib/lutaml/xmi/liquid_drops/data_type_drop.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class DataTypeDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def xmi_id
+        @model[:xmi_id]
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def attributes
+        @model[:attributes]&.map do |attribute|
+          ::Lutaml::XMI::AttributeDrop.new(attribute)
+        end
+      end
+
+      def operations
+        @model[:operations]&.map do |operation|
+          ::Lutaml::XMI::OperationDrop.new(operation)
+        end
+      end
+
+      def associations
+        @model[:associations]&.map do |association|
+          ::Lutaml::XMI::AssociationDrop.new(association)
+        end
+      end
+
+      def constraints
+        @model[:constraints]&.map do |constraint|
+          ::Lutaml::XMI::ConstraintDrop.new(constraint)
+        end
+      end
+
+      def is_abstract
+        @model[:is_abstract]
+      end
+
+      def definition
+        @model[:definition]
+      end
+
+      def stereotype
+        @model[:stereotype]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/diagram_drop.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class DiagramDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def xmi_id
+        @model[:xmi_id]
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def definition
+        @model[:definition]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/enum_drop.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class EnumDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def xmi_id
+        @model[:xmi_id]
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def values
+        @model[:values].map do |value|
+          ::Lutaml::XMI::EnumOwnedLiteralDrop.new(value)
+        end
+      end
+
+      def definition
+        @model[:definition]
+      end
+
+      def stereotype
+        @model[:stereotype]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/enum_owned_literal_drop.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class EnumOwnedLiteralDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def type
+        @model[:type]
+      end
+
+      def definition
+        @model[:definition]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/klass_drop.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class KlassDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def xmi_id
+        @model[:xmi_id]
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def package
+        ::Lutaml::XMI::PackageDrop.new(@model[:package])
+      end
+
+      def type
+        @model[:type]
+      end
+
+      def attributes
+        @model[:attributes]&.map do |attribute|
+          ::Lutaml::XMI::AttributeDrop.new(attribute)
+        end
+      end
+
+      def associations
+        @model[:associations]&.map do |association|
+          ::Lutaml::XMI::AssociationDrop.new(association)
+        end
+      end
+
+      def operations
+        @model[:operations]&.map do |operation|
+          ::Lutaml::XMI::OperationDrop.new(operation)
+        end
+      end
+
+      def constraints
+        @model[:constraints]&.map do |constraint|
+          ::Lutaml::XMI::ConstraintDrop.new(constraint)
+        end
+      end
+
+      def is_abstract
+        @model[:is_abstract]
+      end
+
+      def definition
+        @model[:definition]
+      end
+
+      def stereotype
+        @model[:stereotype]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/operation_drop.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class OperationDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+      end
+
+      def id
+        @model[:id]
+      end
+
+      def xmi_id
+        @model[:xmi_id]
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def definition
+        @model[:definition]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/package_drop.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class PackageDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+        @children_packages ||= packages.map do |pkg|
+          [pkg, pkg.packages, pkg.packages.map(&:children_packages)]
+        end.flatten.uniq
+      end
+
+      def xmi_id
+        @model[:xmi_id]
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def klasses
+        @model[:classes].map do |klass|
+          ::Lutaml::XMI::KlassDrop.new(klass)
+        end
+      end
+      alias classes klasses
+
+      def enums
+        @model[:enums].map do |enum|
+          ::Lutaml::XMI::EnumDrop.new(enum)
+        end
+      end
+
+      def data_types
+        @model[:data_types].map do |data_type|
+          ::Lutaml::XMI::DataTypeDrop.new(data_type)
+        end
+      end
+
+      def diagrams
+        @model[:diagrams].map do |diagram|
+          ::Lutaml::XMI::DiagramDrop.new(diagram)
+        end
+      end
+
+      def packages
+        @model[:packages].map do |package|
+          ::Lutaml::XMI::PackageDrop.new(package)
+        end
+      end
+
+      def children_packages
+        @children_packages
+      end
+
+      def definition
+        @model[:definition]
+      end
+
+      def stereotype
+        @model[:stereotype]
+      end
+    end
+  end
+end

data/lib/lutaml/xmi/liquid_drops/root_drop.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class RootDrop < Liquid::Drop
+      def initialize(model) # rubocop:disable Lint/MissingSuper
+        @model = model
+        @children_packages ||= packages.map do |pkg|
+          [pkg, pkg.packages, pkg.packages.map(&:children_packages)]
+        end.flatten.uniq
+      end
+
+      def name
+        @model[:name]
+      end
+
+      def packages
+        @model[:packages].map do |package|
+          ::Lutaml::XMI::PackageDrop.new(package)
+        end
+      end
+
+      def children_packages
+        @children_packages
+      end
+    end
+  end
+end

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

@@ -16,13 +16,44 @@ 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
+          # @return [Liquid::Drop]
+          def serialize_xmi_to_liquid(xml)
+            xmi_model = get_xmi_model(xml)
+            new.serialize_xmi_to_liquid(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 +61,37 @@ 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]
+        # return [Liquid::Drop]
+        def serialize_xmi_to_liquid(xmi_model)
+          @xmi_cache = {}
+          @xmi_root_model = xmi_model
+          serialized_hash = serialize_xmi(xmi_model)
+
+          ::Lutaml::XMI::RootDrop.new(serialized_hash)
+        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 +166,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 +419,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 +621,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 +639,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 +793,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)

data/lib/lutaml/xmi.rb

@@ -1,5 +1,10 @@
 require "lutaml/xmi/version"
 require "lutaml/xmi/parsers/xml"
+require "liquid"
+
+Dir["#{File.dirname(__FILE__)}/xmi/liquid_drops/**/*.rb"].sort.each do |f|
+  require f
+end
 
 module Lutaml
   module XMI

data/lutaml.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 2.7.0"
 
+  spec.add_runtime_dependency "liquid"
   spec.add_runtime_dependency "expressir", "~> 1.3"
   spec.add_runtime_dependency "hashie", "~> 4.1.0"
   spec.add_runtime_dependency "htmlentities"
@@ -45,4 +46,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.11"
   spec.add_development_dependency "rubocop", "~> 1.58"
   spec.add_development_dependency "rubocop-performance", "~> 1.19"
-end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lutaml
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.11
 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: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: expressir
   requirement: !ruby/object:Gem::Requirement
@@ -354,6 +368,18 @@ files:
 - lib/lutaml/version.rb
 - lib/lutaml/xmi.rb
 - lib/lutaml/xmi/README.adoc
+- lib/lutaml/xmi/liquid_drops/association_drop.rb
+- lib/lutaml/xmi/liquid_drops/attribute_drop.rb
+- lib/lutaml/xmi/liquid_drops/cardinality_drop.rb
+- lib/lutaml/xmi/liquid_drops/constraint_drop.rb
+- lib/lutaml/xmi/liquid_drops/data_type_drop.rb
+- lib/lutaml/xmi/liquid_drops/diagram_drop.rb
+- lib/lutaml/xmi/liquid_drops/enum_drop.rb
+- lib/lutaml/xmi/liquid_drops/enum_owned_literal_drop.rb
+- lib/lutaml/xmi/liquid_drops/klass_drop.rb
+- lib/lutaml/xmi/liquid_drops/operation_drop.rb
+- lib/lutaml/xmi/liquid_drops/package_drop.rb
+- lib/lutaml/xmi/liquid_drops/root_drop.rb
 - lib/lutaml/xmi/parsers/xml.rb
 - lib/lutaml/xmi/version.rb
 - lib/lutaml/xml.rb