ea 0.1.0 → 0.1.4

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class PackageDrop < 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]
+        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
+
+        def klasses
+          Array(@model.classes).map do |klass|
+            ::Ea::Xmi::LiquidDrops::KlassDrop.new(
+              klass,
+              @guidance,
+              @options.merge(
+                {
+                  absolute_path: "#{@options[:absolute_path]}::#{name}",
+                },
+              ),
+            )
+          end
+        end
+        alias classes klasses
+
+        def enums
+          Array(@model.enums).map do |enum|
+            ::Ea::Xmi::LiquidDrops::EnumDrop.new(enum, @options)
+          end
+        end
+
+        def data_types
+          Array(@model.data_types).map do |data_type|
+            ::Ea::Xmi::LiquidDrops::DataTypeDrop.new(data_type, @options)
+          end
+        end
+
+        def diagrams
+          Array(@model.diagrams).map do |diagram|
+            ::Ea::Xmi::LiquidDrops::DiagramDrop.new(diagram, @options)
+          end
+        end
+
+        def packages
+          Array(@model.packages).map do |package|
+            ::Ea::Xmi::LiquidDrops::PackageDrop.new(
+              package,
+              @guidance,
+              @options.merge(
+                {
+                  absolute_path: "#{@options[:absolute_path]}::#{name}",
+                },
+              ),
+            )
+          end
+        end
+
+        def children_packages
+          Array(@model.children_packages).map do |package|
+            ::Ea::Xmi::LiquidDrops::PackageDrop.new(
+              package,
+              @guidance,
+              @options.merge(
+                {
+                  absolute_path: "#{@options[:absolute_path]}::#{name}",
+                },
+              ),
+            )
+          end
+        end
+
+        def definition
+          @model.definition
+        end
+
+        def stereotype
+          @model.stereotype&.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class RootDrop < Liquid::Drop
+        def initialize(model, guidance = nil, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = model
+          @guidance = guidance
+          @options = options
+          @xmi_root_model = options[:xmi_root_model]
+          @id_name_mapping = options[:id_name_mapping]
+
+          @options[:absolute_path] = "::#{model.name}"
+        end
+
+        def name
+          @model.name
+        end
+
+        def packages
+          Array(@model.packages).map do |package|
+            ::Ea::Xmi::LiquidDrops::PackageDrop.new(package, @guidance,
+                                                        @options)
+          end
+        end
+
+        def children_packages
+          Array(@model.packages).flat_map(&:children_packages).uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    module LiquidDrops
+      class SourceTargetDrop < Liquid::Drop
+        def initialize(model, options = {}) # rubocop:disable Lint/MissingSuper
+          @model = model
+          @options = options
+          @lookup = options[:lookup]
+        end
+
+        def idref
+          @model.idref
+        end
+
+        def name
+          @model&.role&.name
+        end
+
+        def type
+          @model&.model&.name
+        end
+
+        def documentation
+          @model&.documentation&.value
+        end
+
+        def multiplicity
+          @model&.type&.multiplicity
+        end
+
+        def aggregation
+          @model&.type&.aggregation
+        end
+
+        def stereotype
+          @lookup.doc_node_attribute_value(@model.idref, "stereotype")
+        end
+      end
+    end
+  end
+end

data/lib/ea/xmi/lookup_service.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Ea
+  module Xmi
+    # Bridge between Liquid Drop classes and the XMI parser.
+    # Drops receive an instance of this service to look up XMI elements.
+    class LookupService
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def doc_node_attribute_value(node_id, attr_name)
+        @parser.doc_node_attribute_value(node_id, attr_name)
+      end
+
+      def lookup_entity_name(xmi_id)
+        @parser.lookup_entity_name(xmi_id)
+      end
+
+      def lookup_attribute_documentation(xmi_id)
+        @parser.lookup_attribute_documentation(xmi_id)
+      end
+
+      def find_upper_level_packaged_element(klass_id)
+        @parser.find_upper_level_packaged_element(klass_id)
+      end
+
+      def find_packaged_element_by_id(id)
+        @parser.find_packaged_element_by_id(id)
+      end
+
+      def get_ns_by_xmi_id(xmi_id)
+        @parser.get_ns_by_xmi_id(xmi_id)
+      end
+
+      def lookup_assoc_def(association)
+        @parser.lookup_assoc_def(association)
+      end
+
+      def fetch_connector(link_id)
+        @parser.fetch_connector(link_id)
+      end
+
+      def fetch_definition_node_value(link_id, node_name)
+        @parser.fetch_definition_node_value(link_id, node_name)
+      end
+
+      def select_dependencies_by_supplier(supplier_id)
+        @parser.select_dependencies_by_supplier(supplier_id)
+      end
+
+      def select_dependencies_by_client(client_id)
+        @parser.select_dependencies_by_client(client_id)
+      end
+
+      def select_all_packaged_elements(all_elements, model, type)
+        @parser.select_all_packaged_elements(all_elements, model, type)
+      end
+
+      def find_subtype_of_from_generalization(id)
+        @parser.find_subtype_of_from_generalization(id)
+      end
+
+      def find_subtype_of_from_owned_attribute_type(id)
+        @parser.find_subtype_of_from_owned_attribute_type(id)
+      end
+
+      def get_package_name(package)
+        @parser.get_package_name(package)
+      end
+
+      def xmi_index
+        @parser.xmi_index
+      end
+
+      def find_matched_element(xmi_id)
+        xmi_index&.find_element(xmi_id)
+      end
+
+      def xmi_root_model
+        @parser.xmi_root_model
+      end
+
+      def id_name_mapping
+        @parser.id_name_mapping
+      end
+    end
+  end
+end