lutaml 0.9.11 → 0.9.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9de4708a54b2e1e0cd6994dc7931e56711d2e257d1077f96003c4f8de6260c7e
-  data.tar.gz: 461a1f380240be81347038fac000ab836067599ac3485ed7d9e5ba61594f379f
+  metadata.gz: 05c32d8cfd15503c91aa70205b2cf130785f6fb5c2c14e6622b0131f530a74d9
+  data.tar.gz: 1aefef310bed4c0438bb37dfdbfac9cf2a9748744f779ae4ecb1eccc18941bb5
 SHA512:
-  metadata.gz: 40e3e939f49e84407257d9d80cebe83e42ef74ba87d5763f5f0c245d445b857273bce8576f24948a4e0e836fa6df2a6f15980c7add173176910a3180da5b4477
-  data.tar.gz: 0c0c19132496f42ee08b6f9773d1807be9df6f4a3ada9ac49a3d846ee612742db086ca7e15494afbfee601f6ca6571ea532a28a2758f61c7576ba255602718ef
+  metadata.gz: 517a71b871804994c345e2676ec6f462efa698c4247bb77b7d3cbd62ce82025d53421a0f67ebf0645e0c47ebfbf9f4ae77629cceab3d4bf1af19548981e01f51
+  data.tar.gz: 4bdcc32531aae771bd148c57d4a41a391afe4eb35d74ff96c1276832ed4cb03c38c42c6407d543e8842240137819a04effd821473e2fd9d7b298ef04a926981e

data/lib/lutaml/version.rb

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

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class GeneralizationAttributeDrop < Liquid::Drop
+      LOWER_VALUE_MAPPINGS = {
+        "C" => "0",
+        "M" => "1",
+      }.freeze
+
+      def initialize(attr, upper_klass, gen_name) # rubocop:disable Lint/MissingSuper
+        @attr = attr
+        @upper_klass = upper_klass
+        @gen_name = gen_name
+      end
+
+      def id
+        @attr[:id]
+      end
+
+      def name
+        @attr[:name]
+      end
+
+      def type
+        @attr[:type]
+      end
+
+      def xmi_id
+        @attr[:xmi_id]
+      end
+
+      def is_derived
+        @attr[:is_derived]
+      end
+
+      def cardinality
+        min = @attr[:cardinality]["min"]
+        min = min.nil? ? nil : LOWER_VALUE_MAPPINGS[min]
+
+        "#{min}..#{@attr[:cardinality]['max']}"
+      end
+
+      def min_cardinality
+        @attr[:cardinality]["min"]
+      end
+
+      def max_cardinality
+        @attr[:cardinality]["max"]
+      end
+
+      def definition
+        @attr[:definition]
+      end
+
+      def association
+        @attr[:association]
+      end
+
+      def has_association?
+        !!@attr[:association]
+      end
+
+      def type_ns
+        @attr[:type_ns]
+      end
+
+      def upper_klass
+        @upper_klass
+      end
+
+      def gen_name
+        @gen_name
+      end
+
+      def name_ns
+        name_ns = case @attr[:type_ns]
+                  when "core", "gml"
+                    upper_klass
+                  else
+                    @attr[:type_ns]
+                  end
+
+        name_ns = upper_klass if name_ns.nil?
+        name_ns
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module XMI
+    class GeneralizationDrop < Liquid::Drop
+      def initialize(gen) # rubocop:disable Lint/MissingSuper
+        @gen = gen
+        @looped_general_item = false
+        @inherited_props = []
+        @inherited_assoc_props = []
+      end
+
+      def id
+        @gen[:general_id]
+      end
+
+      def name
+        @gen[:general_name]
+      end
+
+      def upper_klass
+        @gen[:general_upper_klass]
+      end
+
+      def general
+        GeneralizationDrop.new(@gen[:general]) if @gen[:general]
+      end
+
+      def has_general?
+        !!@gen[:general]
+      end
+
+      def attributes
+        @gen[:general_attributes]
+        # @gen[:general_attributes].map do |attr|
+        #   GeneralizationAttributeDrop.new(attr, upper_klass, name)
+        # end
+      end
+
+      def type
+        @gen[:type]
+      end
+
+      def definition
+        @gen[:definition]
+      end
+
+      def stereotype
+        @gen[:stereotype]
+      end
+
+      # get attributes without association
+      def owned_props
+        attributes.select do |attr|
+          attr[:association].nil?
+        end.map do |attr|
+          GeneralizationAttributeDrop.new(attr, upper_klass, name)
+        end
+      end
+
+      # get attributes with association
+      def assoc_props
+        attributes.select do |attr|
+          attr[:association]
+        end.map do |attr|
+          GeneralizationAttributeDrop.new(attr, upper_klass, name)
+        end
+      end
+
+      # get items without association by looping through the generation
+      def inherited_props
+        loop_general_item unless @looped_general_item
+
+        @inherited_props.reverse
+      end
+
+      # get items with association by looping through the generation
+      def inherited_assoc_props
+        loop_general_item unless @looped_general_item
+
+        @inherited_assoc_props.reverse
+      end
+
+      def loop_general_item # rubocop:disable Metrics/MethodLength
+        general_item = general
+        while general_item.has_general?
+          gen_upper_klass = general_item.upper_klass
+          gen_name = general_item.name
+          # reverse the order to show super class first
+          general_item.attributes.reverse_each do |attr|
+            attr_drop = GeneralizationAttributeDrop.new(attr, gen_upper_klass,
+                                                        gen_name)
+            if attr[:association]
+              @inherited_assoc_props << attr_drop
+            else
+              @inherited_props << attr_drop
+            end
+          end
+
+          general_item = general_item.general
+        end
+
+        @looped_general_item = true
+      end
+    end
+  end
+end

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

@@ -47,6 +47,12 @@ module Lutaml
         end
       end
 
+      def generalization
+        return {} if @model[:generalization].nil?
+
+        ::Lutaml::XMI::GeneralizationDrop.new(@model[:generalization])
+      end
+
       def is_abstract
         @model[:is_abstract]
       end

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

@@ -26,10 +26,11 @@ module Lutaml
           end
 
           # @param xml [String] path to xml
+          # @param with_gen [Boolean]
           # @return [Hash]
-          def serialize_xmi(xml)
+          def serialize_xmi(xml, with_gen: false)
             xmi_model = get_xmi_model(xml)
-            new.serialize_xmi(xmi_model)
+            new.serialize_xmi(xmi_model, with_gen: with_gen)
           end
 
           # @param xml [String] path to xml
@@ -57,10 +58,15 @@ module Lutaml
         end
 
         # @param xmi_model [Shale::Mapper]
-        # @return [Lutaml::Uml::Document]
-        def parse(xmi_model)
+        def set_xmi_model(xmi_model)
           @xmi_cache = {}
           @xmi_root_model = xmi_model
+        end
+
+        # @param xmi_model [Shale::Mapper]
+        # @return [Lutaml::Uml::Document]
+        def parse(xmi_model)
+          set_xmi_model(xmi_model)
           serialized_hash = serialize_xmi(xmi_model)
 
           ::Lutaml::Uml::Document.new(serialized_hash)
@@ -68,18 +74,16 @@ module Lutaml
 
         # @param xmi_model [Shale::Mapper]
         # return [Hash]
-        def serialize_xmi(xmi_model)
-          @xmi_cache = {}
-          @xmi_root_model = xmi_model
-          serialize_to_hash(xmi_model)
+        def serialize_xmi(xmi_model, with_gen: false)
+          set_xmi_model(xmi_model)
+          serialize_to_hash(xmi_model, with_gen: with_gen)
         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)
+          set_xmi_model(xmi_model)
+          serialized_hash = serialize_xmi(xmi_model, with_gen: true)
 
           ::Lutaml::XMI::RootDrop.new(serialized_hash)
         end
@@ -88,10 +92,11 @@ module Lutaml
         # @param name [String]
         # @return [Hash]
         def serialize_generalization_by_name(xmi_model, name)
-          @xmi_cache = {}
-          @xmi_root_model = xmi_model
+          set_xmi_model(xmi_model)
           klass = find_klass_packaged_element_by_name(name)
-          serialize_generalization(klass)
+          serialized_hash = serialize_generalization(klass)
+
+          ::Lutaml::XMI::GeneralizationDrop.new(serialized_hash)
         end
 
         private
@@ -99,29 +104,30 @@ module Lutaml
         # @param xmi_model [Shale::Mapper]
         # @return [Hash]
         # @note xpath: //uml:Model[@xmi:type="uml:Model"]
-        def serialize_to_hash(xmi_model)
+        def serialize_to_hash(xmi_model, with_gen: false)
           model = xmi_model.model
           {
             name: model.name,
-            packages: serialize_model_packages(model),
+            packages: serialize_model_packages(model, with_gen: with_gen),
           }
         end
 
         # @param model [Shale::Mapper]
         # @return [Array<Hash>]
         # @note xpath ./packagedElement[@xmi:type="uml:Package"]
-        def serialize_model_packages(model)
+        def serialize_model_packages(model, with_gen: false)
           model.packaged_element.select do |e|
             e.type?("uml:Package")
           end.map do |package|
             {
               xmi_id: package.id,
               name: get_package_name(package),
-              classes: serialize_model_classes(package, model),
+              classes: serialize_model_classes(package, model,
+                                               with_gen: with_gen),
               enums: serialize_model_enums(package),
               data_types: serialize_model_data_types(package),
               diagrams: serialize_model_diagrams(package.id),
-              packages: serialize_model_packages(package),
+              packages: serialize_model_packages(package, with_gen: with_gen),
               definition: doc_node_attribute_value(package.id, "documentation"),
               stereotype: doc_node_attribute_value(package.id, "stereotype"),
             }
@@ -145,25 +151,38 @@ module Lutaml
         # @return [Array<Hash>]
         # @note xpath ./packagedElement[@xmi:type="uml:Class" or
         #                               @xmi:type="uml:AssociationClass"]
-        def serialize_model_classes(package, model)
+        def serialize_model_classes(package, model, with_gen: false)
           package.packaged_element.select do |e|
             e.type?("uml:Class") || e.type?("uml:AssociationClass") ||
               e.type?("uml:Interface")
           end.map do |klass|
-            {
-              xmi_id: klass.id,
-              name: klass.name,
-              package: model,
-              type: klass.type.split(":").last,
-              attributes: serialize_class_attributes(klass),
-              associations: serialize_model_associations(klass.id),
-              operations: serialize_class_operations(klass),
-              constraints: serialize_class_constraints(klass.id),
-              is_abstract: doc_node_attribute_value(klass.id, "isAbstract"),
-              definition: doc_node_attribute_value(klass.id, "documentation"),
-              stereotype: doc_node_attribute_value(klass.id, "stereotype"),
-            }
+            build_klass_hash(klass, model, with_gen: with_gen)
+          end
+        end
+
+        # @param klass [Shale::Mapper]
+        # @param model [Shale::Mapper]
+        # @return [Hash]
+        def build_klass_hash(klass, model, with_gen: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          klass_hash = {
+            xmi_id: klass.id,
+            name: klass.name,
+            package: model,
+            type: klass.type.split(":").last,
+            attributes: serialize_class_attributes(klass),
+            associations: serialize_model_associations(klass.id),
+            operations: serialize_class_operations(klass),
+            constraints: serialize_class_constraints(klass.id),
+            is_abstract: doc_node_attribute_value(klass.id, "isAbstract"),
+            definition: doc_node_attribute_value(klass.id, "documentation"),
+            stereotype: doc_node_attribute_value(klass.id, "stereotype"),
+          }
+
+          if with_gen && klass.type?("uml:Class")
+            klass_hash[:generalization] = serialize_generalization(klass)
           end
+
+          klass_hash
         end
 
         # @param klass [Shale::Mapper]
@@ -237,8 +256,9 @@ module Lutaml
         # @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] }
+          serialize_class_attributes(general_node, with_assoc: true)
+          # turn on sorting if necessary
+          # attrs.sort_by { |i| i[:name] }
         end
 
         # @param general_node [Shale::Mapper]
@@ -251,6 +271,8 @@ module Lutaml
         # @return [Array<Hash>]
         def get_general_hash(general_id)
           general_node = get_general_node(general_id)
+          return [] unless general_node
+
           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)
@@ -714,6 +736,8 @@ module Lutaml
           return unless type
 
           p = find_klass_packaged_element_by_name(type)
+          return unless p
+
           find_upper_level_packaged_element(p.id)
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml
 version: !ruby/object:Gem::Version
-  version: 0.9.11
+  version: 0.9.13
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -376,6 +376,8 @@ files:
 - 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/generalization_attribute_drop.rb
+- lib/lutaml/xmi/liquid_drops/generalization_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