lutaml 0.9.27 → 0.9.29

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

@@ -3,24 +3,26 @@
 module Lutaml
   module XMI
     class ConstraintDrop < Liquid::Drop
+      include Parsers::XMIBase
+
       def initialize(model) # rubocop:disable Lint/MissingSuper
         @model = model
       end
 
       def name
-        @model[:name]
+        HTMLEntities.new.decode(@model.name)
       end
 
       def type
-        @model[:type]
+        @model.type
       end
 
       def weight
-        @model[:weight]
+        @model.weight
       end
 
       def status
-        @model[:status]
+        @model.status
       end
     end
   end

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

@@ -3,52 +3,110 @@
 module Lutaml
   module XMI
     class DataTypeDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper,Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         @model = model
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
+
+        @owned_attributes = model&.owned_attribute&.select do |attr|
+          attr.type?("uml:Property")
+        end
+
+        if @xmi_root_model
+          @matched_element = @xmi_root_model&.extension&.elements&.element&.find do |e| # rubocop:disable Layout/LineLength,Style/SafeNavigationChainLength
+            e.idref == @model.id
+          end
+        end
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @model.id
       end
 
       def name
-        @model[:name]
+        @model.name
       end
 
       def attributes
-        @model[:attributes]&.map do |attribute|
-          ::Lutaml::XMI::AttributeDrop.new(attribute)
-        end
+        @owned_attributes.map do |owned_attr|
+          if @options[:with_assoc] || owned_attr.association.nil?
+            ::Lutaml::XMI::AttributeDrop.new(owned_attr, @options)
+          end
+        end.compact
       end
 
       def operations
-        @model[:operations]&.map do |operation|
-          ::Lutaml::XMI::OperationDrop.new(operation)
-        end
+        @model.owned_operation.map do |operation|
+          if operation.association.nil?
+            ::Lutaml::XMI::OperationDrop.new(operation)
+          end
+        end.compact
       end
 
-      def associations
-        @model[:associations]&.map do |association|
-          ::Lutaml::XMI::AssociationDrop.new(association)
-        end
+      def associations # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+        return if !@matched_element ||
+          !@matched_element.links ||
+          @matched_element.links.association.empty?
+
+        @matched_element.links.association.map do |assoc|
+          link_member = assoc.start == xmi_id ? "end" : "start"
+          link_owner_name = link_member == "start" ? "end" : "start"
+
+          member_end, member_end_type, member_end_cardinality,
+            member_end_attribute_name, member_end_xmi_id =
+            serialize_member_type(xmi_id, assoc, link_member)
+
+          owner_end = serialize_owned_type(xmi_id, assoc, link_owner_name)
+
+          if member_end && ((member_end_type != "aggregation") ||
+            (member_end_type == "aggregation" && member_end_attribute_name))
+
+            doc_node_name = (link_member == "start" ? "source" : "target")
+            definition = fetch_definition_node_value(assoc.id, doc_node_name)
+
+            ::Lutaml::XMI::AssociationDrop.new(
+              xmi_id: assoc.id,
+              member_end: member_end,
+              member_end_type: member_end_type,
+              member_end_cardinality: member_end_cardinality,
+              member_end_attribute_name: member_end_attribute_name,
+              member_end_xmi_id: member_end_xmi_id,
+              owner_end: owner_end,
+              owner_end_xmi_id: xmi_id,
+              definition: definition,
+            )
+          end
+        end.compact
       end
 
       def constraints
-        @model[:constraints]&.map do |constraint|
+        connector_node = fetch_connector(@model.id)
+        return unless connector_node
+
+        # In ea-xmi-2.5.1, constraints are moved to source/target under
+        # connectors
+        constraints = %i[source target].map do |st|
+          connector_node.send(st).constraints.constraint
+        end.flatten
+
+        constraints.map do |constraint|
           ::Lutaml::XMI::ConstraintDrop.new(constraint)
         end
       end
 
-      def is_abstract
-        @model[:is_abstract]
+      def is_abstract # rubocop:disable Naming/PredicateName
+        doc_node_attribute_value(@model.id, "isAbstract")
       end
 
       def definition
-        @model[:definition]
+        doc_node_attribute_value(@model.id, "documentation")
       end
 
       def stereotype
-        @model[:stereotype]
+        doc_node_attribute_value(@model.id, "stereotype")
       end
     end
   end

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

@@ -3,28 +3,35 @@
 module Lutaml
   module XMI
     class DiagramDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
         @model = model
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @model.id
       end
 
       def name
-        @model[:name]
+        @model.properties.name
       end
 
       def definition
-        @model[:definition]
+        @model.properties.documentation
       end
 
       def package_id
-        @model[:package_id]
+        @model.model.package if @options[:with_gen]
       end
 
       def package_name
-        @model[:package_name]
+        if @options[:with_gen] && package_id
+          find_packaged_element_by_id(package_id)&.name
+        end
       end
     end
   end

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

@@ -3,30 +3,39 @@
 module Lutaml
   module XMI
     class EnumDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
         @model = model
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
+
+        @owned_literals = model&.owned_literal&.select do |owned_literal|
+          owned_literal.type? "uml:EnumerationLiteral"
+        end
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @model.id
       end
 
       def name
-        @model[:name]
+        @model.name
       end
 
       def values
-        @model[:values].map do |value|
-          ::Lutaml::XMI::EnumOwnedLiteralDrop.new(value)
+        @owned_literals.map do |owned_literal|
+          ::Lutaml::XMI::EnumOwnedLiteralDrop.new(owned_literal, @options)
         end
       end
 
       def definition
-        @model[:definition]
+        doc_node_attribute_value(@model.id, "documentation")
       end
 
       def stereotype
-        @model[:stereotype]
+        doc_node_attribute_value(@model.id, "stereotype")
       end
     end
   end

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

@@ -3,20 +3,26 @@
 module Lutaml
   module XMI
     class EnumOwnedLiteralDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
         @model = model
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
       end
 
       def name
-        @model[:name]
+        @model.name
       end
 
       def type
-        @model[:type]
+        uml_type_id = @model&.uml_type&.idref
+        lookup_entity_name(uml_type_id) || uml_type_id
       end
 
       def definition
-        @model[:definition]
+        lookup_attribute_documentation(@model.id)
       end
     end
   end

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

@@ -3,6 +3,8 @@
 module Lutaml
   module XMI
     class GeneralizationAttributeDrop < Liquid::Drop
+      include Parsers::XMIBase
+
       def initialize(attr, upper_klass, gen_name, guidance = nil) # rubocop:disable Lint/MissingSuper,Metrics/ParameterLists,Layout/LineLength
         @attr = attr
         @upper_klass = upper_klass

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

@@ -3,12 +3,17 @@
 module Lutaml
   module XMI
     class GeneralizationDrop < Liquid::Drop
-      def initialize(gen, guidance = nil) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(gen, guidance = nil, options = {}) # rubocop:disable Lint/MissingSuper
         @gen = gen
         @looped_general_item = false
         @inherited_props = []
         @inherited_assoc_props = []
         @guidance = guidance
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
       end
 
       def id
@@ -24,14 +29,16 @@ module Lutaml
       end
 
       def general
-        GeneralizationDrop.new(@gen[:general], @guidance) if @gen[:general]
+        if @gen[:general]
+          GeneralizationDrop.new(@gen[:general], @guidance, @options)
+        end
       end
 
       def has_general?
         !!@gen[:general]
       end
 
-      def attributes
+      def attributes # rubocop:disable Metrics/MethodLength
         attrs = @gen[:general_attributes]
         attrs.each do |i|
           name_ns = case i[:type_ns]

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

@@ -3,9 +3,28 @@
 module Lutaml
   module XMI
     class KlassDrop < Liquid::Drop
-      def initialize(model, guidance = nil) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, guidance = nil, options = {}) # rubocop:disable Lint/MissingSuper,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
         @model = model
         @guidance = guidance
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
+
+        @package = model&.packaged_element&.find do |e|
+          e.type?("uml:Package")
+        end
+
+        @owned_attributes = model&.owned_attribute&.select do |attr|
+          attr.type?("uml:Property")
+        end
+
+        if @xmi_root_model
+          @matched_element = @xmi_root_model&.extension&.elements&.element&.find do |e| # rubocop:disable Layout/LineLength,Style/SafeNavigationChainLength
+            e.idref == @model.id
+          end
+        end
 
         if guidance
           @klass_guidance = guidance["classes"].find do |klass|
@@ -15,70 +34,125 @@ module Lutaml
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @model.id
       end
 
       def name
-        @model[:name]
+        @model.name
       end
 
       def absolute_path
-        "#{@model[:absolute_path]}::#{name}"
+        "#{@options[:absolute_path]}::#{name}"
       end
 
       def package
-        ::Lutaml::XMI::PackageDrop.new(@model[:package], @guidance)
+        ::Lutaml::XMI::PackageDrop.new(
+          @package,
+          @guidance,
+          @options.merge(
+            {
+              absolute_path: "#{@options[:absolute_path]}::#{name}",
+            },
+          ),
+        )
       end
 
       def type
-        @model[:type]
+        @model.type.split(":").last
       end
 
       def attributes
-        @model[:attributes]&.map do |attribute|
-          ::Lutaml::XMI::AttributeDrop.new(attribute)
-        end
+        @owned_attributes.map do |owned_attr|
+          if @options[:with_assoc] || owned_attr.association.nil?
+            ::Lutaml::XMI::AttributeDrop.new(owned_attr, @options)
+          end
+        end.compact
       end
 
-      def associations
-        @model[:associations]&.map do |association|
-          ::Lutaml::XMI::AssociationDrop.new(association)
-        end
+      def associations # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+        return if !@matched_element ||
+          !@matched_element.links ||
+          @matched_element.links.association.empty?
+
+        @matched_element.links.association.map do |assoc|
+          link_member = assoc.start == xmi_id ? "end" : "start"
+          link_owner_name = link_member == "start" ? "end" : "start"
+
+          member_end, member_end_type, member_end_cardinality,
+            member_end_attribute_name, member_end_xmi_id =
+            serialize_member_type(xmi_id, assoc, link_member)
+
+          owner_end = serialize_owned_type(xmi_id, assoc, link_owner_name)
+
+          if member_end && ((member_end_type != "aggregation") ||
+            (member_end_type == "aggregation" && member_end_attribute_name))
+
+            doc_node_name = (link_member == "start" ? "source" : "target")
+            definition = fetch_definition_node_value(assoc.id, doc_node_name)
+
+            ::Lutaml::XMI::AssociationDrop.new(
+              xmi_id: assoc.id,
+              member_end: member_end,
+              member_end_type: member_end_type,
+              member_end_cardinality: member_end_cardinality,
+              member_end_attribute_name: member_end_attribute_name,
+              member_end_xmi_id: member_end_xmi_id,
+              owner_end: owner_end,
+              owner_end_xmi_id: xmi_id,
+              definition: definition,
+            )
+          end
+        end.compact
       end
 
       def operations
-        @model[:operations]&.map do |operation|
-          ::Lutaml::XMI::OperationDrop.new(operation)
-        end
+        @model.owned_operation.map do |operation|
+          if operation.association.nil?
+            ::Lutaml::XMI::OperationDrop.new(operation)
+          end
+        end.compact
       end
 
       def constraints
-        @model[:constraints]&.map do |constraint|
+        connector_node = fetch_connector(@model.id)
+        return unless connector_node
+
+        # In ea-xmi-2.5.1, constraints are moved to source/target under
+        # connectors
+        constraints = %i[source target].map do |st|
+          connector_node.send(st).constraints.constraint
+        end.flatten
+
+        constraints.map do |constraint|
           ::Lutaml::XMI::ConstraintDrop.new(constraint)
         end
       end
 
       def generalization
-        return {} if @model[:generalization].nil?
+        if @options[:with_gen] && @model.type?("uml:Class")
+          generalization = serialize_generalization(@model)
+          return {} if generalization.nil?
 
-        ::Lutaml::XMI::GeneralizationDrop.new(@model[:generalization],
-                                              @klass_guidance)
+          ::Lutaml::XMI::GeneralizationDrop.new(
+            generalization, @klass_guidance, @options
+          )
+        end
       end
 
       def has_guidance?
         !!@klass_guidance
       end
 
-      def is_abstract
-        @model[:is_abstract]
+      def is_abstract # rubocop:disable Naming/PredicateName
+        doc_node_attribute_value(@model.id, "isAbstract")
       end
 
       def definition
-        @model[:definition]
+        doc_node_attribute_value(@model.id, "documentation")
       end
 
       def stereotype
-        @model[:stereotype]
+        doc_node_attribute_value(@model.id, "stereotype")
       end
     end
   end

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

@@ -3,24 +3,30 @@
 module Lutaml
   module XMI
     class OperationDrop < Liquid::Drop
-      def initialize(model) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
         @model = model
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
       end
 
       def id
-        @model[:id]
+        @model.id
       end
 
       def xmi_id
-        @model[:xmi_id]
+        uml_type = @model.uml_type.first
+        uml_type&.idref
       end
 
       def name
-        @model[:name]
+        @model.name
       end
 
       def definition
-        @model[:definition]
+        lookup_attribute_documentation(@model.id)
       end
     end
   end

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

@@ -3,55 +3,98 @@
 module Lutaml
   module XMI
     class PackageDrop < Liquid::Drop
-      def initialize(model, guidance = nil) # rubocop:disable Lint/MissingSuper
+      include Parsers::XMIBase
+
+      def initialize(model, guidance = nil, options = {}) # rubocop:disable Lint/MissingSuper,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
         @model = model
         @guidance = guidance
 
+        @options = options
+        @xmi_root_model = options[:xmi_root_model]
+        @xmi_cache = options[:xmi_cache]
+
+        @packages = model.packaged_element.select do |e|
+          e.type?("uml:Package")
+        end
+
+        @klasses = model.packaged_element.select do |e|
+          e.type?("uml:Class") || e.type?("uml:AssociationClass") ||
+            e.type?("uml:Interface")
+        end
+
+        @all_data_type_elements = []
+        select_all_packaged_elements(@all_data_type_elements, model,
+                                     "uml:DataType")
+
         @children_packages ||= packages.map do |pkg|
           [pkg, pkg.packages, pkg.packages.map(&:children_packages)]
         end.flatten.uniq
       end
 
       def xmi_id
-        @model[:xmi_id]
+        @model.id
       end
 
       def name
-        @model[:name]
+        get_package_name(@model)
       end
 
       def absolute_path
-        @model[:absolute_path]
+        "#{@options[:absolute_path]}::#{name}"
       end
 
-      def klasses
-        @model[:classes].map do |klass|
-          ::Lutaml::XMI::KlassDrop.new(klass, @guidance)
+      def klasses # rubocop:disable Metrics/MethodLength
+        @klasses.map do |klass|
+          ::Lutaml::XMI::KlassDrop.new(
+            klass,
+            @guidance,
+            @options.merge(
+              {
+                absolute_path: "#{@options[:absolute_path]}::#{name}",
+              },
+            ),
+          )
         end
       end
       alias classes klasses
 
       def enums
-        @model[:enums].map do |enum|
-          ::Lutaml::XMI::EnumDrop.new(enum)
+        enums = @model.packaged_element.select do |e|
+          e.type?("uml:Enumeration")
+        end
+
+        enums.map do |enum|
+          ::Lutaml::XMI::EnumDrop.new(enum, @options)
         end
       end
 
       def data_types
-        @model[:data_types].map do |data_type|
-          ::Lutaml::XMI::DataTypeDrop.new(data_type)
+        @all_data_type_elements.map do |data_type|
+          ::Lutaml::XMI::DataTypeDrop.new(data_type, @options)
         end
       end
 
       def diagrams
-        @model[:diagrams].map do |diagram|
-          ::Lutaml::XMI::DiagramDrop.new(diagram)
+        diagrams = @xmi_root_model.extension.diagrams.diagram.select do |d|
+          d.model.package == @model.id
+        end
+
+        diagrams.map do |diagram|
+          ::Lutaml::XMI::DiagramDrop.new(diagram, @options)
         end
       end
 
-      def packages
-        @model[:packages].map do |package|
-          ::Lutaml::XMI::PackageDrop.new(package, @guidance)
+      def packages # rubocop:disable Metrics/MethodLength
+        @packages.map do |package|
+          ::Lutaml::XMI::PackageDrop.new(
+            package,
+            @guidance,
+            @options.merge(
+              {
+                absolute_path: "#{@options[:absolute_path]}::#{name}",
+              },
+            ),
+          )
         end
       end
 
@@ -60,11 +103,11 @@ module Lutaml
       end
 
       def definition
-        @model[:definition]
+        doc_node_attribute_value(@model.id, "documentation")
       end
 
       def stereotype
-        @model[:stereotype]
+        doc_node_attribute_value(@model.id, "stereotype")
       end
     end
   end