ea 0.1.0 → 0.1.4

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ea
+  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?
+              ::Ea::Xmi::LiquidDrops::AttributeDrop.new(owned_attr,
+                                                            @options)
+            end
+          end
+        end
+
+        def operations
+          Array(@model.operations).map do |operation|
+            ::Ea::Xmi::LiquidDrops::OperationDrop.new(operation)
+          end
+        end
+
+        def associations
+          Array(@model.associations).filter_map do |assoc|
+            ::Ea::Xmi::LiquidDrops::AssociationDrop.new(assoc, @options)
+          end
+        end
+
+        def constraints
+          Array(@model.constraints).map do |constraint|
+            ::Ea::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/ea/xmi/liquid_drops/dependency_drop.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ea
+  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)
+          ::Ea::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  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/ea/xmi/liquid_drops/enum_drop.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ea
+  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|
+            ::Ea::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/ea/xmi/liquid_drops/enum_owned_literal_drop.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ea
+  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/ea/xmi/liquid_drops/generalization_attribute_drop.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Ea
+  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
+          ::Ea::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/ea/xmi/liquid_drops/generalization_drop.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Ea
+  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/ea/xmi/liquid_drops/klass_drop.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Ea
+  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
+
+          ::Ea::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?
+              ::Ea::Xmi::LiquidDrops::AttributeDrop.new(owned_attr,
+                                                            @options)
+            end
+          end
+        end
+
+        def owned_attributes
+          Array(@model.attributes).filter_map do |owned_attr|
+            ::Ea::Xmi::LiquidDrops::AttributeDrop.new(owned_attr, @options)
+          end
+        end
+
+        def suppliers_dependencies
+          Array(@suppliers_dependencies).filter_map do |dependency|
+            ::Ea::Xmi::LiquidDrops::DependencyDrop.new(dependency, @options)
+          end
+        end
+
+        def clients_dependencies
+          Array(@clients_dependencies).filter_map do |dependency|
+            ::Ea::Xmi::LiquidDrops::DependencyDrop.new(dependency, @options)
+          end
+        end
+
+        def inheritances
+          Array(@inheritance_ids).filter_map do |inheritance_id|
+            connector = @lookup.fetch_connector(inheritance_id)
+            ::Ea::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
+          end
+        end
+
+        def associations
+          Array(@model.associations).filter_map do |assoc|
+            ::Ea::Xmi::LiquidDrops::AssociationDrop.new(assoc, @options)
+          end
+        end
+
+        def operations
+          Array(@model.operations).map do |operation|
+            ::Ea::Xmi::LiquidDrops::OperationDrop.new(operation)
+          end
+        end
+
+        def constraints
+          Array(@model.constraints).map do |constraint|
+            ::Ea::Xmi::LiquidDrops::ConstraintDrop.new(constraint)
+          end
+        end
+
+        def generalization
+          if @options[:with_gen] && @model.generalization
+            ::Ea::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

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

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