lutaml 0.10.19 → 0.11.2

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class ConnectorDrop < Liquid::Drop
-        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-          @model = model
-          @options = options
-          @id_name_mapping = options[:id_name_mapping]
-        end
-
-        def idref
-          @model.idref
-        end
-
-        def name
-          @model.name
-        end
-
-        def type
-          @model&.properties&.ea_type
-        end
-
-        def documentation
-          @model&.documentation&.value
-        end
-
-        def ea_type
-          @model&.properties&.ea_type
-        end
-
-        def direction
-          @model&.properties&.direction
-        end
-
-        def source
-          ::Lutaml::Xmi::LiquidDrops::SourceTargetDrop.new(@model.source,
-                                                           @options)
-        end
-
-        def target
-          ::Lutaml::Xmi::LiquidDrops::SourceTargetDrop.new(@model.target,
-                                                           @options)
-        end
-
-        def recognized?
-          !!@id_name_mapping[@model.source.idref] &&
-            !!@id_name_mapping[@model.target.idref]
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      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
-end

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class DataTypeDrop < Liquid::Drop
-        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-          @model = model
-          @options = options
-          @lookup = options[:lookup]
-          @xmi_root_model = options[:xmi_root_model]
-        end
-
-        def xmi_id
-          @model.xmi_id
-        end
-
-        def name
-          @model.name
-        end
-
-        def attributes
-          Array(@model.attributes).filter_map do |owned_attr|
-            if @options[:with_assoc] || owned_attr.association.nil?
-              ::Lutaml::Xmi::LiquidDrops::AttributeDrop.new(owned_attr,
-                                                            @options)
-            end
-          end
-        end
-
-        def operations
-          Array(@model.operations).map do |operation|
-            ::Lutaml::Xmi::LiquidDrops::OperationDrop.new(operation)
-          end
-        end
-
-        def associations
-          Array(@model.associations).filter_map do |assoc|
-            ::Lutaml::Xmi::LiquidDrops::AssociationDrop.new(assoc, @options)
-          end
-        end
-
-        def constraints
-          Array(@model.constraints).map do |constraint|
-            ::Lutaml::Xmi::LiquidDrops::ConstraintDrop.new(constraint)
-          end
-        end
-
-        def is_abstract # rubocop:disable Naming/PredicateName,Naming/PredicatePrefix
-          @model.is_abstract
-        end
-
-        def definition
-          @model.definition
-        end
-
-        def stereotype
-          @model.stereotype&.first
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class DependencyDrop < Liquid::Drop
-        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-          @model = model
-          @options = options
-          @lookup = options[:lookup]
-        end
-
-        def id
-          @model.id
-        end
-
-        def name
-          @model.name
-        end
-
-        def ea_type
-          @model&.properties&.ea_type
-        end
-
-        def documentation
-          @model&.documentation&.value
-        end
-
-        def connector
-          connector = @lookup.fetch_connector(@model.id)
-          ::Lutaml::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class DiagramDrop < Liquid::Drop
-        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-          @model = model
-          @options = options
-        end
-
-        def xmi_id
-          @model.xmi_id
-        end
-
-        def name
-          @model.name
-        end
-
-        def definition
-          @model.definition
-        end
-
-        def package_id
-          @model.package_id if @options[:with_gen]
-        end
-
-        def package_name
-          @model.package_name if @options[:with_gen]
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class EnumDrop < Liquid::Drop
-        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
-          @model = model
-          @options = options
-          @lookup = options[:lookup]
-        end
-
-        def xmi_id
-          @model.xmi_id
-        end
-
-        def name
-          @model.name
-        end
-
-        def values
-          Array(@model.values).map do |value|
-            ::Lutaml::Xmi::LiquidDrops::EnumOwnedLiteralDrop.new(value)
-          end
-        end
-
-        def definition
-          @model.definition
-        end
-
-        def stereotype
-          @model.stereotype&.first
-        end
-
-        # @return name of the upper packaged element
-        def upper_packaged_element
-          if @options[:with_gen]
-            e = @lookup.find_upper_level_packaged_element(@model.xmi_id)
-            e&.name
-          end
-        end
-
-        def subtype_of
-          @lookup.find_subtype_of_from_owned_attribute_type(@model.xmi_id)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      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
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class GeneralizationAttributeDrop < Liquid::Drop
-        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
-
-        def name
-          @attr.name
-        end
-
-        def type
-          @attr.type
-        end
-
-        def xmi_id
-          @attr.xmi_id
-        end
-
-        def is_derived # rubocop:disable Naming/PredicateName,Naming/PredicatePrefix
-          @attr.is_derived
-        end
-
-        def cardinality
-          ::Lutaml::Xmi::LiquidDrops::CardinalityDrop.new(@attr.cardinality)
-        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
-          @attr.name_ns
-        end
-
-        def used?
-          if @guidance
-            col_name = "#{name_ns}:#{name}"
-            attr = @guidance["attributes"].find { |a| a["name"] == col_name }
-            return attr["used"].to_s if attr
-          end
-
-          "true"
-        end
-
-        def guidance
-          if @guidance
-            col_name = "#{name_ns}:#{name}"
-            attr = @guidance["attributes"].find { |a| a["name"] == col_name }
-
-            attr["guidance"] if attr
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class GeneralizationDrop < Liquid::Drop
-        def initialize(gen, guidance = nil, options = {}) # rubocop:disable Lint/MissingSuper
-          @gen = gen
-          @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
-
-        def name
-          @gen.general_name
-        end
-
-        def upper_klass
-          @gen.general_upper_klass
-        end
-
-        def general
-          if @gen.general
-            GeneralizationDrop.new(@gen.general, @guidance, @options)
-          end
-        end
-
-        def has_general?
-          !@gen.general.nil?
-        end
-
-        def attributes
-          @gen.general_attributes
-        end
-
-        def type
-          @gen.type
-        end
-
-        def definition
-          @gen.definition
-        end
-
-        def stereotype
-          @gen.stereotype
-        end
-
-        # get attributes without association
-        def owned_props(sort: false)
-          return [] unless @gen.owned_props
-
-          props = @gen.owned_props
-          props = sort_props(props) if sort
-          props_to_liquid(props)
-        end
-
-        # get attributes with association
-        def assoc_props(sort: false)
-          return [] unless @gen.assoc_props
-
-          props = @gen.assoc_props
-          props = sort_props(props) if sort
-          props_to_liquid(props)
-        end
-
-        def props_to_liquid(props)
-          props.map do |attr|
-            GeneralizationAttributeDrop.new(attr, attr.upper_klass,
-                                            attr.gen_name, @guidance)
-          end
-        end
-
-        # get items without association by looping through the generation
-        def inherited_props(sort: false)
-          return [] unless @gen.inherited_props
-
-          props = @gen.inherited_props
-          props = sort_props_with_level(props) if sort
-          props_to_liquid(props)
-        end
-
-        # get items with association by looping through the generation
-        def inherited_assoc_props(sort: false)
-          return [] unless @gen.inherited_assoc_props
-
-          props = @gen.inherited_assoc_props
-          props = sort_props_with_level(props) if sort
-          props_to_liquid(props)
-        end
-
-        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.name_ns.to_s, i.name.to_s] }
-        end
-
-        def sorted_owned_props
-          owned_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_assoc_props
-          inherited_assoc_props(sort: true)
-        end
-
-        def sort_props(arr)
-          return [] if arr.nil? || arr.empty?
-
-          arr.sort_by { |i| [i.name_ns.to_s, i.name.to_s] }
-        end
-      end
-    end
-  end
-end

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

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Xmi
-    module LiquidDrops
-      class KlassDrop < Liquid::Drop
-        def initialize(model, guidance = nil, options = {}) # rubocop:disable Lint/MissingSuper
-          @model = model
-          @guidance = guidance
-          @options = options
-          @lookup = options[:lookup]
-          @xmi_root_model = options[:xmi_root_model]
-          @id_name_mapping = options[:id_name_mapping]
-
-          init_xmi_dependencies if @xmi_root_model
-          init_guidance(guidance) if guidance
-        end
-
-        def xmi_id
-          @model.xmi_id
-        end
-
-        def name
-          @model.name
-        end
-
-        def absolute_path
-          absolute_path_arr = [@model.name]
-          e = @lookup.find_upper_level_packaged_element(@model.xmi_id)
-          absolute_path_arr << e.name if e
-
-          while e
-            e = @lookup.find_upper_level_packaged_element(e.id)
-            absolute_path_arr << e.name if e
-          end
-
-          absolute_path_arr << "::#{@xmi_root_model.model.name}"
-          absolute_path_arr.reverse.join("::")
-        end
-
-        private
-
-        def init_xmi_dependencies
-          @clients_dependencies = @lookup.select_dependencies_by_supplier(@model.xmi_id)
-          @suppliers_dependencies = @lookup.select_dependencies_by_client(@model.xmi_id)
-
-          matched_element = @lookup.find_matched_element(@model.xmi_id)
-          @inheritance_ids = extract_inheritance_ids(matched_element)
-        end
-
-        def init_guidance(guidance)
-          @klass_guidance = guidance["classes"].find do |klass|
-            klass["name"] == name || klass["name"] == absolute_path
-          end
-        end
-
-        def extract_inheritance_ids(matched_element)
-          return [] unless matched_element
-
-          links = matched_element.links
-          return [] unless links
-
-          links.flat_map do |link|
-            link.generalization
-              .select { |gen| gen.end == @model.xmi_id }
-              .map(&:id)
-          end.compact
-        end
-
-        public
-
-        def package
-          xmi_pkg = find_nested_xmi_package
-          return unless xmi_pkg
-
-          ::Lutaml::Xmi::LiquidDrops::PackageDrop.new(
-            build_uml_package(xmi_pkg),
-            @guidance,
-            @options.merge(absolute_path: "#{@options[:absolute_path]}::#{name}"),
-          )
-        end
-
-        def find_nested_xmi_package
-          nested_pkg = @lookup.find_packaged_element_by_id(@model.xmi_id)
-          return unless nested_pkg
-
-          nested_pkg.packaged_element&.find { |e| e.type?("uml:Package") }
-        end
-
-        def build_uml_package(xmi_pkg)
-          uml_pkg = ::Lutaml::Uml::Package.new
-          uml_pkg.xmi_id = xmi_pkg.id
-          uml_pkg.name = @lookup.get_package_name(xmi_pkg)
-          uml_pkg
-        end
-
-        def type
-          @model.type
-        end
-
-        def attributes
-          Array(@model.attributes).filter_map do |owned_attr|
-            if @options[:with_assoc] || owned_attr.association.nil?
-              ::Lutaml::Xmi::LiquidDrops::AttributeDrop.new(owned_attr,
-                                                            @options)
-            end
-          end
-        end
-
-        def owned_attributes
-          Array(@model.attributes).filter_map do |owned_attr|
-            ::Lutaml::Xmi::LiquidDrops::AttributeDrop.new(owned_attr, @options)
-          end
-        end
-
-        def suppliers_dependencies
-          Array(@suppliers_dependencies).filter_map do |dependency|
-            ::Lutaml::Xmi::LiquidDrops::DependencyDrop.new(dependency, @options)
-          end
-        end
-
-        def clients_dependencies
-          Array(@clients_dependencies).filter_map do |dependency|
-            ::Lutaml::Xmi::LiquidDrops::DependencyDrop.new(dependency, @options)
-          end
-        end
-
-        def inheritances
-          Array(@inheritance_ids).filter_map do |inheritance_id|
-            connector = @lookup.fetch_connector(inheritance_id)
-            ::Lutaml::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
-          end
-        end
-
-        def associations
-          Array(@model.associations).filter_map do |assoc|
-            ::Lutaml::Xmi::LiquidDrops::AssociationDrop.new(assoc, @options)
-          end
-        end
-
-        def operations
-          Array(@model.operations).map do |operation|
-            ::Lutaml::Xmi::LiquidDrops::OperationDrop.new(operation)
-          end
-        end
-
-        def constraints
-          Array(@model.constraints).map do |constraint|
-            ::Lutaml::Xmi::LiquidDrops::ConstraintDrop.new(constraint)
-          end
-        end
-
-        def generalization
-          if @options[:with_gen] && @model.generalization
-            ::Lutaml::Xmi::LiquidDrops::GeneralizationDrop.new(
-              @model.generalization, @klass_guidance, @options
-            )
-          end
-        end
-
-        def upper_packaged_element
-          if @options[:with_gen]
-            e = @lookup.find_upper_level_packaged_element(@model.xmi_id)
-            e&.name
-          end
-        end
-
-        def subtype_of
-          @lookup.find_subtype_of_from_generalization(@model.xmi_id) ||
-            @lookup.find_subtype_of_from_owned_attribute_type(@model.xmi_id)
-        end
-
-        def has_guidance?
-          !!@klass_guidance
-        end
-
-        def is_abstract # rubocop:disable Naming/PredicateName,Naming/PredicatePrefix
-          @model.is_abstract
-        end
-
-        def definition
-          @model.definition
-        end
-
-        def stereotype
-          @model.stereotype&.first
-        end
-      end
-    end
-  end
-end