lutaml 0.9.43 → 0.10.0

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

@@ -1,53 +1,56 @@
 # frozen_string_literal: true
 
 module Lutaml
-  module XMI
-    class EnumDrop < Liquid::Drop
-      include Parsers::XMIBase
-
-      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-        @model = model
-        @options = options
-        @xmi_root_model = options[:xmi_root_model]
-        @id_name_mapping = options[:id_name_mapping]
-
-        @owned_literals = model&.owned_literal&.select do |owned_literal|
-          owned_literal.type? "uml:EnumerationLiteral"
+  module Xmi
+    module LiquidDrops
+      class EnumDrop < Liquid::Drop
+        include Parsers::XmiBase
+
+        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = model
+          @options = options
+          @xmi_root_model = options[:xmi_root_model]
+          @id_name_mapping = options[:id_name_mapping]
+
+          @owned_literals = model&.owned_literal&.select do |owned_literal|
+            owned_literal.type? "uml:EnumerationLiteral"
+          end
         end
-      end
 
-      def xmi_id
-        @model.id
-      end
+        def xmi_id
+          @model.id
+        end
 
-      def name
-        @model.name
-      end
+        def name
+          @model.name
+        end
 
-      def values
-        @owned_literals.map do |owned_literal|
-          ::Lutaml::XMI::EnumOwnedLiteralDrop.new(owned_literal, @options)
+        def values
+          @owned_literals.map do |owned_literal|
+            ::Lutaml::Xmi::LiquidDrops::EnumOwnedLiteralDrop.new(owned_literal,
+                                                                 @options)
+          end
         end
-      end
 
-      def definition
-        doc_node_attribute_value(@model.id, "documentation")
-      end
+        def definition
+          doc_node_attribute_value(@model.id, "documentation")
+        end
 
-      def stereotype
-        doc_node_attribute_value(@model.id, "stereotype")
-      end
+        def stereotype
+          doc_node_attribute_value(@model.id, "stereotype")
+        end
 
-      # @return name of the upper packaged element
-      def upper_packaged_element
-        if @options[:with_gen]
-          e = find_upper_level_packaged_element(@model.id)
-          e&.name
+        # @return name of the upper packaged element
+        def upper_packaged_element
+          if @options[:with_gen]
+            e = find_upper_level_packaged_element(@model.id)
+            e&.name
+          end
         end
-      end
 
-      def subtype_of
-        find_subtype_of_from_owned_attribute_type(@model.id)
+        def subtype_of
+          find_subtype_of_from_owned_attribute_type(@model.id)
+        end
       end
     end
   end

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

@@ -1,28 +1,30 @@
 # frozen_string_literal: true
 
 module Lutaml
-  module XMI
-    class EnumOwnedLiteralDrop < Liquid::Drop
-      include Parsers::XMIBase
+  module Xmi
+    module LiquidDrops
+      class EnumOwnedLiteralDrop < Liquid::Drop
+        include Parsers::XmiBase
 
-      def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-        @model = model
-        @options = options
-        @xmi_root_model = options[:xmi_root_model]
-        @id_name_mapping = options[:id_name_mapping]
-      end
+        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = model
+          @options = options
+          @xmi_root_model = options[:xmi_root_model]
+          @id_name_mapping = options[:id_name_mapping]
+        end
 
-      def name
-        @model.name
-      end
+        def name
+          @model.name
+        end
 
-      def type
-        uml_type_id = @model&.uml_type&.idref
-        lookup_entity_name(uml_type_id) || uml_type_id
-      end
+        def type
+          uml_type_id = @model&.uml_type&.idref
+          lookup_entity_name(uml_type_id) || uml_type_id
+        end
 
-      def definition
-        lookup_attribute_documentation(@model.id)
+        def definition
+          lookup_attribute_documentation(@model.id)
+        end
       end
     end
   end

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

@@ -1,85 +1,87 @@
 # frozen_string_literal: true
 
 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
-        @gen_name = gen_name
-        @guidance = guidance
-      end
-
-      def id
-        @attr[:id]
-      end
+  module Xmi
+    module LiquidDrops
+      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
+          @gen_name = gen_name
+          @guidance = guidance
+        end
 
-      def name
-        @attr[:name]
-      end
+        def id
+          @attr[:id]
+        end
 
-      def type
-        @attr[:type]
-      end
+        def name
+          @attr[:name]
+        end
 
-      def xmi_id
-        @attr[:xmi_id]
-      end
+        def type
+          @attr[:type]
+        end
 
-      def is_derived # rubocop:disable Naming/PredicateName,Naming/PredicatePrefix
-        @attr[:is_derived]
-      end
+        def xmi_id
+          @attr[:xmi_id]
+        end
 
-      def cardinality
-        ::Lutaml::XMI::CardinalityDrop.new(@attr[:cardinality])
-      end
+        def is_derived # rubocop:disable Naming/PredicateName,Naming/PredicatePrefix
+          @attr[:is_derived]
+        end
 
-      def definition
-        @attr[:definition]
-      end
+        def cardinality
+          ::Lutaml::Xmi::LiquidDrops::CardinalityDrop.new(@attr[:cardinality])
+        end
 
-      def association
-        @attr[:association]
-      end
+        def definition
+          @attr[:definition]
+        end
 
-      def has_association?
-        !!@attr[:association]
-      end
+        def association
+          @attr[:association]
+        end
 
-      def type_ns
-        @attr[:type_ns]
-      end
+        def has_association?
+          !!@attr[:association]
+        end
 
-      def upper_klass
-        @upper_klass
-      end
+        def type_ns
+          @attr[:type_ns]
+        end
 
-      def gen_name
-        @gen_name
-      end
+        def upper_klass
+          @upper_klass
+        end
 
-      def name_ns
-        @attr[:name_ns]
-      end
+        def gen_name
+          @gen_name
+        end
 
-      def used?
-        if @guidance
-          col_name = "#{name_ns}:#{name}"
-          attr = @guidance["attributes"].find { |a| a["name"] == col_name }
-          return attr["used"] if attr
+        def name_ns
+          @attr[:name_ns]
         end
 
-        true
-      end
+        def used?
+          if @guidance
+            col_name = "#{name_ns}:#{name}"
+            attr = @guidance["attributes"].find { |a| a["name"] == col_name }
+            return attr["used"] if attr
+          end
+
+          true
+        end
 
-      def guidance
-        if @guidance
-          col_name = "#{name_ns}:#{name}"
-          attr = @guidance["attributes"].find { |a| a["name"] == col_name }
+        def guidance
+          if @guidance
+            col_name = "#{name_ns}:#{name}"
+            attr = @guidance["attributes"].find { |a| a["name"] == col_name }
 
-          attr["guidance"] if attr
+            attr["guidance"] if attr
+          end
         end
       end
     end

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

@@ -1,182 +1,184 @@
 # frozen_string_literal: true
 
 module Lutaml
-  module XMI
-    class GeneralizationDrop < Liquid::Drop
-      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]
-        @id_name_mapping = options[:id_name_mapping]
-      end
-
-      def id
-        @gen[:general_id]
-      end
+  module Xmi
+    module LiquidDrops
+      class GeneralizationDrop < Liquid::Drop
+        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]
+          @id_name_mapping = options[:id_name_mapping]
+        end
 
-      def name
-        @gen[:general_name]
-      end
+        def id
+          @gen[:general_id]
+        end
 
-      def upper_klass
-        @gen[:general_upper_klass]
-      end
+        def name
+          @gen[:general_name]
+        end
 
-      def general
-        if @gen[:general]
-          GeneralizationDrop.new(@gen[:general], @guidance, @options)
+        def upper_klass
+          @gen[:general_upper_klass]
         end
-      end
 
-      def has_general?
-        !!@gen[:general]
-      end
+        def general
+          if @gen[:general]
+            GeneralizationDrop.new(@gen[:general], @guidance, @options)
+          end
+        end
 
-      def attributes # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
-        attrs = @gen[:general_attributes]
-        attrs.each do |i|
-          name_ns = case i[:type_ns]
-                    when "core", "gml"
-                      upper_klass&.name
-                    else
-                      i[:type_ns]
-                    end
-          name_ns = upper_klass&.name if name_ns.nil?
+        def has_general?
+          !!@gen[:general]
+        end
 
-          i[:name_ns] = name_ns
-          i[:name] = "" if i[:name].nil?
+        def attributes # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+          attrs = @gen[:general_attributes]
+          attrs.each do |i|
+            name_ns = case i[:type_ns]
+                      when "core", "gml"
+                        upper_klass&.name
+                      else
+                        i[:type_ns]
+                      end
+            name_ns = upper_klass&.name if name_ns.nil?
+
+            i[:name_ns] = name_ns
+            i[:name] = "" if i[:name].nil?
+          end
         end
-      end
 
-      def type
-        @gen[:type]
-      end
+        def type
+          @gen[:type]
+        end
 
-      def definition
-        @gen[:definition]
-      end
+        def definition
+          @gen[:definition]
+        end
 
-      def stereotype
-        @gen[:stereotype]
-      end
+        def stereotype
+          @gen[:stereotype]
+        end
 
-      # get attributes without association
-      def owned_props(sort: false)
-        return [] unless attributes
+        # get attributes without association
+        def owned_props(sort: false)
+          return [] unless attributes
 
-        props = attributes.select { |attr| attr[:association].nil? }
-        props = sort_props(props) if sort
-        props_to_liquid(props)
-      end
+          props = attributes.select { |attr| attr[:association].nil? }
+          props = sort_props(props) if sort
+          props_to_liquid(props)
+        end
 
-      # get attributes with association
-      def assoc_props(sort: false)
-        return [] unless attributes
+        # get attributes with association
+        def assoc_props(sort: false)
+          return [] unless attributes
 
-        props = attributes.select { |attr| attr[:association].nil? == false }
-        props = sort_props(props) if sort
-        props_to_liquid(props)
-      end
+          props = attributes.select { |attr| attr[:association].nil? == false }
+          props = sort_props(props) if sort
+          props_to_liquid(props)
+        end
 
-      def props_to_liquid(props)
-        props.map do |attr|
-          GeneralizationAttributeDrop.new(attr, upper_klass, name, @guidance)
+        def props_to_liquid(props)
+          props.map do |attr|
+            GeneralizationAttributeDrop.new(attr, upper_klass, name, @guidance)
+          end
         end
-      end
 
-      # get items without association by looping through the generation
-      def inherited_props(sort: false)
-        loop_general_item unless @looped_general_item
+        # get items without association by looping through the generation
+        def inherited_props(sort: false)
+          loop_general_item unless @looped_general_item
 
-        props = @inherited_props.reverse
-        props = sort_props_with_level(props) if sort
-        props_hash_to_liquid(props)
-      end
+          props = @inherited_props.reverse
+          props = sort_props_with_level(props) if sort
+          props_hash_to_liquid(props)
+        end
 
-      # get items with association by looping through the generation
-      def inherited_assoc_props(sort: false)
-        loop_general_item unless @looped_general_item
+        # get items with association by looping through the generation
+        def inherited_assoc_props(sort: false)
+          loop_general_item unless @looped_general_item
 
-        props = @inherited_assoc_props.reverse
-        props = sort_props_with_level(props) if sort
-        props_hash_to_liquid(props)
-      end
+          props = @inherited_assoc_props.reverse
+          props = sort_props_with_level(props) if sort
+          props_hash_to_liquid(props)
+        end
 
-      def sort_props_with_level(arr)
-        return [] if arr.nil? || arr.empty?
+        def sort_props_with_level(arr)
+          return [] if arr.nil? || arr.empty?
 
-        # level desc, name_ns asc, name asc
-        arr.sort_by { |i| [-i[:level], i[:attr][:name_ns], i[:attr][:name]] }
-      end
+          # level desc, name_ns asc, name asc
+          arr.sort_by { |i| [-i[:level], i[:attr][:name_ns], i[:attr][:name]] }
+        end
 
-      def props_hash_to_liquid(prop_hash_arr)
-        prop_hash_arr.map do |prop_hash|
-          GeneralizationAttributeDrop.new(
-            prop_hash[:attr],
-            prop_hash[:gen_upper_klass],
-            prop_hash[:gen_name],
-            prop_hash[:guidance],
-          )
+        def props_hash_to_liquid(prop_hash_arr)
+          prop_hash_arr.map do |prop_hash|
+            GeneralizationAttributeDrop.new(
+              prop_hash[:attr],
+              prop_hash[:gen_upper_klass],
+              prop_hash[:gen_name],
+              prop_hash[:guidance],
+            )
+          end
         end
-      end
 
-      def sorted_owned_props
-        owned_props(sort: true)
-      end
+        def sorted_owned_props
+          owned_props(sort: true)
+        end
 
-      def sorted_assoc_props
-        assoc_props(sort: true)
-      end
+        def sorted_assoc_props
+          assoc_props(sort: true)
+        end
 
-      def sorted_inherited_props
-        inherited_props(sort: true)
-      end
+        def sorted_inherited_props
+          inherited_props(sort: true)
+        end
 
-      def sorted_inherited_assoc_props
-        inherited_assoc_props(sort: true)
-      end
+        def sorted_inherited_assoc_props
+          inherited_assoc_props(sort: true)
+        end
 
-      def sort_props(arr)
-        return [] if arr.nil? || arr.empty?
+        def sort_props(arr)
+          return [] if arr.nil? || arr.empty?
 
-        arr.sort_by { |i| [i[:name_ns], i[:name]] }
-      end
+          arr.sort_by { |i| [i[:name_ns], i[:name]] }
+        end
 
-      def loop_general_item # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        general_item = general
-        level = 0
-
-        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_hash = {
-              attr: attr,
-              gen_upper_klass: gen_upper_klass,
-              gen_name: gen_name,
-              guidance: @guidance,
-            }
-            attr_hash[:level] = level
-
-            if attr[:association]
-              @inherited_assoc_props << attr_hash
-            else
-              @inherited_props << attr_hash
+        def loop_general_item # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+          general_item = general
+          level = 0
+
+          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_hash = {
+                attr: attr,
+                gen_upper_klass: gen_upper_klass,
+                gen_name: gen_name,
+                guidance: @guidance,
+              }
+              attr_hash[:level] = level
+
+              if attr[:association]
+                @inherited_assoc_props << attr_hash
+              else
+                @inherited_props << attr_hash
+              end
             end
+
+            level += 1
+            general_item = general_item.general
           end
 
-          level += 1
-          general_item = general_item.general
+          @looped_general_item = true
         end
-
-        @looped_general_item = true
       end
     end
   end