lutaml 0.10.13 → 0.10.15

data/lib/lutaml/cli/tree_view_formatter.rb

@@ -275,13 +275,21 @@ module Lutaml
 
       # Determine class type (class, interface, enumeration)
       def determine_class_type(klass)
-        return :enumeration if klass.class.name&.include?("Enum")
-        return :interface if klass.is_a?(Lutaml::Uml::TopElement) &&
-          Array(klass.stereotype).any? { |s| s&.downcase == "interface" }
+        return :enumeration if enumeration?(klass)
+        return :interface if interface?(klass)
 
         :class
       end
 
+      def enumeration?(klass)
+        klass.class.name&.include?("Enum")
+      end
+
+      def interface?(klass)
+        klass.is_a?(Lutaml::Uml::TopElement) &&
+          Array(klass.stereotype).any? { |s| s&.downcase == "interface" }
+      end
+
       # Find package path for a package object
       def find_package_path(repository, package)
         repository.indexes[:package_paths].each do |path, pkg|

data/lib/lutaml/converter/xmi_to_uml.rb

@@ -148,12 +148,17 @@ module Lutaml
       # Lazy-built hash index for O(1) diagram lookups by package
       # @return [Hash] Mapping of package_id => [diagrams]
       def diagram_lookup
-        @diagram_lookup ||= begin
-          idx = Hash.new { |h, k| h[k] = [] }
-          diagrams = @xmi_root_model.extension&.diagrams&.diagram || []
-          diagrams.each { |d| idx[d.model.package] << d if d.model&.package }
-          idx
-        end
+        @diagram_lookup ||= build_diagram_index
+      end
+
+      def build_diagram_index
+        idx = Hash.new { |h, k| h[k] = [] }
+        xmi_diagrams.each { |d| idx[d.model.package] << d if d.model&.package }
+        idx
+      end
+
+      def xmi_diagrams
+        @xmi_root_model.extension&.diagrams&.diagram || []
       end
 
       def create_uml_class_attributes(klass) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength

data/lib/lutaml/formatter/graphviz.rb

@@ -227,50 +227,65 @@ module Lutaml
         field_table
       end
 
-      def format_class(node, hide_members) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      def format_class(node, hide_members) # rubocop:disable Metrics/MethodLength
         name = ["<B>#{node.name}</B>"]
         name.unshift("«#{node.keyword}»") if node.keyword
-        name_html = <<~HEREDOC
-          <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
-            #{name.map { |n| %(<TR><TD ALIGN="CENTER">#{n}</TD></TR>) }.join('\n')}
-          </TABLE>
-        HEREDOC
+        name_html = build_name_table(name)
 
         field_table = format_member_rows(node.attributes, hide_members)
         method_table = if node.operations&.any?
                          format_member_rows(node.operations, hide_members)
                        end
-        table_body = [name_html, field_table, method_table].map do |type|
-          next if type.nil?
+        table_body = build_table_body(name_html, field_table, method_table)
+
+        <<~HEREDOC.chomp
+          <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="10">
+            #{table_body}
+          </TABLE>
+        HEREDOC
+      end
+
+      def build_name_table(name_parts)
+        <<~HEREDOC
+          <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+            #{name_parts.map { |n| %(<TR><TD ALIGN="CENTER">#{n}</TD></TR>) }.join('\n')}
+          </TABLE>
+        HEREDOC
+      end
 
+      def build_table_body(name_html, field_table, method_table)
+        [name_html, field_table, method_table].compact.filter_map do |type|
           <<~TEXT
             <TR>
               <TD>#{type}</TD>
             </TR>
           TEXT
-        end
-
-        <<~HEREDOC.chomp
-          <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="10">
-            #{table_body.compact.join("\n")}
-          </TABLE>
-        HEREDOC
+        end.join("\n")
       end
 
-      def format_document(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      def format_document(node)
         @fontname = node.fontname || DEFAULT_CLASS_FONT
         @node["fontname"] = "#{@fontname}-bold"
 
+        hide_members, hide_other_classes = extract_fidelity_options(node)
+        classes = format_all_classes(node, hide_members)
+        associations = build_associations(node, hide_other_classes)
+
+        build_digraph(classes, associations)
+      end
+
+      def extract_fidelity_options(node)
         if node.fidelity
-          hide_members = node.fidelity.hideMembers
-          hide_other_classes = node.fidelity.hideOtherClasses
+          [node.fidelity.hideMembers, node.fidelity.hideOtherClasses]
+        else
+          [nil, nil]
         end
-        classes = (node.classes +
-                    node.enums +
-                    node.data_types +
-                    node.primitives).map do |class_node|
-          graph_node_name = generate_graph_name(class_node.name)
+      end
 
+      def format_all_classes(node, hide_members)
+        all_classes = node.classes + node.enums + node.data_types + node.primitives
+        all_classes.map do |class_node|
+          graph_node_name = generate_graph_name(class_node.name)
           <<~HEREDOC
             #{graph_node_name} [
               shape="plain"
@@ -278,25 +293,36 @@ module Lutaml
               label=<#{format_class(class_node, hide_members)}>]
           HEREDOC
         end.join("\n")
-        associations = node.classes.filter_map(&:associations).flatten +
-          node.associations
+      end
+
+      def build_associations(node, hide_other_classes)
+        associations = collect_all_associations(node)
         if node.groups
           associations = sort_by_document_grouping(node.groups,
                                                    associations)
         end
+
         classes_names = node.classes.map(&:name)
-        associations = associations.map do |assoc_node|
-          if hide_other_classes &&
-              !classes_names.include?(assoc_node.member_end)
-            next
-          end
+        format_filtered_associations(associations, classes_names,
+                                     hide_other_classes)
+      end
+
+      def collect_all_associations(node)
+        node.classes.filter_map(&:associations).flatten + node.associations
+      end
+
+      def format_filtered_associations(associations, classes_names,
+hide_other_classes)
+        associations.filter_map do |assoc_node|
+          next if hide_other_classes && !classes_names.include?(assoc_node.member_end)
 
           format_relationship(assoc_node)
         end.join("\n")
+      end
 
-        classes = classes.lines.map { |line| "  #{line}" }.join.chomp
-        associations = associations
-          .lines.map { |line| "  #{line}" }.join.chomp
+      def build_digraph(classes, associations)
+        indented_classes = indent_lines(classes)
+        indented_assocs = indent_lines(associations)
 
         <<~HEREDOC
           digraph G {
@@ -304,13 +330,17 @@ module Lutaml
             edge [#{@edge}]
             node [#{@node}]
 
-          #{classes}
+          #{indented_classes}
 
-          #{associations}
+          #{indented_assocs}
           }
         HEREDOC
       end
 
+      def indent_lines(text)
+        text.lines.map { |line| "  #{line}" }.join.chomp
+      end
+
       protected
 
       def sort_by_document_grouping(groups, associations) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity

data/lib/lutaml/model_transformations/parsers/base_parser.rb

@@ -55,7 +55,7 @@ module Lutaml
         # @param file_path [String] Path to the model file
         # @return [Lutaml::Uml::Document] Parsed UML document
         # @raise [ParseError] if parsing fails
-        def parse(file_path) # rubocop:disable Metrics/MethodLength
+        def parse(file_path)
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           @stats_mutex.synchronize { @parse_stats[:total_parses] += 1 }
           parse_succeeded = false
@@ -65,37 +65,35 @@ module Lutaml
             validate_file!(file_path) if should_validate_input?
             clear_errors_and_warnings
 
-            begin
-              # Pre-parsing hook
-              before_parse(file_path)
-
-              # Core parsing (implemented by subclasses)
-              document = parse_internal(file_path)
+            parse_succeeded, result = execute_parse(file_path)
+            parse_handled = !parse_succeeded
+            result
+          ensure
+            record_parse_stats(parse_succeeded, parse_handled, start_time)
+          end
+        end
 
-              # Post-parsing processing
-              document = after_parse(document, file_path)
+        def execute_parse(file_path)
+          before_parse(file_path)
+          document = parse_internal(file_path)
+          document = after_parse(document, file_path)
+          validate_output!(document) if should_validate_output?
 
-              # Validate output if requested
-              validate_output!(document) if should_validate_output?
+          @stats_mutex.synchronize { @parse_stats[:successful_parses] += 1 }
+          [true, document]
+        rescue StandardError => e
+          [false, handle_parsing_error(e, file_path)]
+        end
 
-              parse_succeeded = true
-              @stats_mutex.synchronize { @parse_stats[:successful_parses] += 1 }
-              document
-            rescue StandardError => e
-              parse_handled = true
-              @stats_mutex.synchronize { @parse_stats[:failed_parses] += 1 }
-              handle_parsing_error(e, file_path)
-            end
-          ensure
-            unless parse_succeeded || parse_handled
-              @stats_mutex.synchronize { @parse_stats[:failed_parses] += 1 }
-            end
-            duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-            @last_duration = duration
-            @stats_mutex.synchronize do
-              @parse_stats[:total_duration] += duration
-              @parse_stats[:durations] << duration
-            end
+        def record_parse_stats(succeeded, handled, start_time)
+          unless succeeded || handled
+            @stats_mutex.synchronize { @parse_stats[:failed_parses] += 1 }
+          end
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+          @last_duration = duration
+          @stats_mutex.synchronize do
+            @parse_stats[:total_duration] += duration
+            @parse_stats[:durations] << duration
           end
         end
 

data/lib/lutaml/qea/factory/association_builder.rb

@@ -11,147 +11,48 @@ module Lutaml
         def load_class_associations(object_id, object_guid)
           return [] if object_id.nil?
 
-          associations = []
           normalized_owner_xmi_id = normalize_guid_to_xmi_format(object_guid,
                                                                  "EAID")
 
           assoc_connectors = database.connectors_for_object(object_id)
             .select { |c| ASSOC_TYPES.include?(c.connector_type) }
 
-          assoc_connectors.each do |ea_connector|
-            is_start = ea_connector.start_object_id == object_id
-
-            owner_end_attribute_name = if is_start
-                                         ea_connector.destrole
-                                       else
-                                         ea_connector.sourcerole
-                                       end
-
-            if owner_end_attribute_name.nil? || owner_end_attribute_name.empty?
-              next
-            end
-
-            member_obj = if is_start
-                           find_object_by_id(ea_connector.end_object_id)
-                         else
-                           find_object_by_id(ea_connector.start_object_id)
-                         end
-            next unless member_obj
-
-            member_end_attribute_name = if is_start
-                                          ea_connector.sourcerole
-                                        else
-                                          ea_connector.destrole
-                                        end
-            if member_end_attribute_name.nil? ||
-                member_end_attribute_name.empty?
-              member_end_attribute_name = member_obj.name
-            end
-
-            member_cardinality_str = if is_start
-                                       ea_connector.destcard
-                                     else
-                                       ea_connector.sourcecard
-                                     end
-
-            associations << Lutaml::Uml::Association.new.tap do |assoc|
-              assoc.xmi_id = normalize_guid_to_xmi_format(ea_connector.ea_guid,
-                                                          "EAID")
-              assoc.name = ea_connector.name unless ea_connector.name.nil? || ea_connector.name.empty?
-
-              assoc.owner_end = find_object_by_id(object_id)&.name
-              assoc.owner_end_xmi_id = normalized_owner_xmi_id
-              assoc.owner_end_attribute_name = owner_end_attribute_name
-
-              assoc.member_end = member_obj.name
-              assoc.member_end_xmi_id = normalize_guid_to_xmi_format(
-                member_obj.ea_guid, "EAID"
-              )
-              assoc.member_end_attribute_name = member_end_attribute_name
-
-              assoc.member_end_type = ea_connector.connector_type&.downcase
-
-              if member_cardinality_str && !member_cardinality_str.empty?
-                parsed = parse_cardinality(member_cardinality_str)
-                if parsed[:min] || parsed[:max]
-                  assoc.member_end_cardinality = Lutaml::Uml::Cardinality.new
-                    .tap do |card|
-                      card.min = parsed[:min]
-                      card.max = parsed[:max]
-                    end
-                end
-              end
-            end
+          assoc_connectors.filter_map do |ea_connector|
+            build_association(ea_connector, object_id, normalized_owner_xmi_id)
           end
-
-          associations.compact
         end
 
         def load_association_attributes(object_id)
           return [] if object_id.nil?
 
-          attributes = []
           assoc_connectors = database.connectors_for_object(object_id)
             .select { |c| ASSOC_TYPES.include?(c.connector_type) }
           obj = find_object_by_id(object_id)
           obj_pkg_name = find_package_name(obj&.package_id)
 
-          assoc_connectors.each do |ea_connector|
-            if ea_connector.start_object_id == object_id
-              next if ea_connector.destrole.nil? || ea_connector.destrole.empty?
-
-              target_obj = find_object_by_id(ea_connector.end_object_id)
-              next unless target_obj
-
-              target_obj_pkg_name = find_package_name(target_obj.package_id)
-
-              attributes << create_association_attribute(
-                name: ea_connector.destrole,
-                type: target_obj.name,
-                type_xmi_id: target_obj.ea_guid,
-                association_xmi_id: ea_connector.ea_guid,
-                cardinality: ea_connector.destcard,
-                definition: ea_connector.notes,
-                gen_name: obj.name,
-                name_ns: obj_pkg_name,
-                type_ns: target_obj_pkg_name,
-                is_src: false,
-              )
-            elsif ea_connector.end_object_id == object_id
-              next if ea_connector.sourcerole.nil? || ea_connector.sourcerole.empty?
-
-              source_obj = find_object_by_id(ea_connector.start_object_id)
-              next unless source_obj
-
-              source_obj_pkg_name = find_package_name(source_obj.package_id)
-
-              attributes << create_association_attribute(
-                name: ea_connector.sourcerole,
-                type: source_obj.name,
-                type_xmi_id: source_obj.ea_guid,
-                association_xmi_id: ea_connector.ea_guid,
-                cardinality: ea_connector.sourcecard,
-                definition: ea_connector.notes,
-                gen_name: obj.name,
-                name_ns: obj_pkg_name,
-                type_ns: source_obj_pkg_name,
-              )
-            end
+          assoc_connectors.filter_map do |ea_connector|
+            build_connector_attribute(ea_connector, object_id, obj,
+                                      obj_pkg_name)
           end
+        end
 
-          attributes.compact
+        def build_connector_attribute(ea_connector, object_id, obj,
+obj_pkg_name)
+          if ea_connector.start_object_id == object_id
+            build_end_attribute(ea_connector, obj, obj_pkg_name)
+          elsif ea_connector.end_object_id == object_id
+            build_start_attribute(ea_connector, obj, obj_pkg_name)
+          end
         end
 
-        def create_association_attribute( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/ParameterLists
+        def create_association_attribute( # rubocop:disable Metrics/ParameterLists
           name:, type:, type_xmi_id:,
           association_xmi_id:, cardinality:, definition:,
           gen_name:, name_ns:, type_ns:, is_src: true
         )
           Lutaml::Uml::GeneralAttribute.new.tap do |attr|
-            attr.name = name
-            attr.type = type
-            attr.gen_name = gen_name
-            attr.definition = definition
+            assign_assoc_attr_basic(attr, name, type, gen_name, definition,
+                                    name_ns, type_ns)
             attr.xmi_id = normalize_guid_to_xmi_format(type_xmi_id, "EAID")
             attr.association = normalize_guid_to_xmi_format(
               association_xmi_id, "EAID"
@@ -160,23 +61,139 @@ module Lutaml
             attr.id = normalize_guid_to_xmi_src_dst_format(
               association_xmi_id, "EAID", is_src
             )
-            attr.name_ns = name_ns
-            attr.type_ns = type_ns
-
-            if cardinality && !cardinality.empty?
-              parsed = parse_cardinality(cardinality)
-              if parsed[:min] || parsed[:max]
-                attr.cardinality = Lutaml::Uml::Cardinality.new.tap do |card|
-                  card.min = parsed[:min]
-                  card.max = parsed[:max]
-                end
-              end
-            end
+            attr.cardinality = build_cardinality(cardinality)
           end
         end
 
         private
 
+        def assign_assoc_attr_basic(attr, name, type, gen_name,
+                                    definition, name_ns, type_ns)
+          attr.name = name
+          attr.type = type
+          attr.gen_name = gen_name
+          attr.definition = definition
+          attr.name_ns = name_ns
+          attr.type_ns = type_ns
+        end
+
+        def build_association(ea_connector, object_id, normalized_owner_xmi_id)
+          is_start = ea_connector.start_object_id == object_id
+          owner_role = is_start ? ea_connector.destrole : ea_connector.sourcerole
+          return nil if owner_role.nil? || owner_role.empty?
+
+          member_obj = resolve_member_object(ea_connector, is_start)
+          return nil unless member_obj
+
+          member_role = resolve_member_role(ea_connector, is_start, member_obj)
+
+          build_association_record(ea_connector, object_id, normalized_owner_xmi_id,
+                                   owner_role, member_obj, member_role, is_start)
+        end
+
+        def build_association_record(ea_connector, object_id, owner_xmi_id,
+                                     owner_role, member_obj, member_role, is_start)
+          cardinality_str = is_start ? ea_connector.destcard : ea_connector.sourcecard
+
+          Lutaml::Uml::Association.new.tap do |assoc|
+            assoc.xmi_id = normalize_guid_to_xmi_format(ea_connector.ea_guid,
+                                                        "EAID")
+            assign_assoc_name(assoc, ea_connector)
+            assign_association_ends(assoc, object_id, owner_xmi_id,
+                                    owner_role, member_obj, member_role)
+            assoc.member_end_type = ea_connector.connector_type&.downcase
+            assoc.member_end_cardinality = build_cardinality(cardinality_str)
+          end
+        end
+
+        def assign_assoc_name(assoc, ea_connector)
+          return if ea_connector.name.nil? || ea_connector.name.empty?
+
+          assoc.name = ea_connector.name
+        end
+
+        def assign_association_ends(assoc, object_id, owner_xmi_id,
+                                    owner_role, member_obj, member_role)
+          assoc.owner_end = find_object_by_id(object_id)&.name
+          assoc.owner_end_xmi_id = owner_xmi_id
+          assoc.owner_end_attribute_name = owner_role
+          assoc.member_end = member_obj.name
+          assoc.member_end_xmi_id = normalize_guid_to_xmi_format(
+            member_obj.ea_guid, "EAID"
+          )
+          assoc.member_end_attribute_name = member_role
+        end
+
+        def resolve_member_object(ea_connector, is_start)
+          peer_id = is_start ? ea_connector.end_object_id : ea_connector.start_object_id
+          find_object_by_id(peer_id)
+        end
+
+        def resolve_member_role(ea_connector, is_start, member_obj)
+          role = is_start ? ea_connector.sourcerole : ea_connector.destrole
+          role.nil? || role.empty? ? member_obj.name : role
+        end
+
+        def build_end_attribute(ea_connector, obj, obj_pkg_name)
+          return nil if ea_connector.destrole.nil? || ea_connector.destrole.empty?
+
+          target_obj = find_object_by_id(ea_connector.end_object_id)
+          return nil unless target_obj
+
+          build_directional_attribute(
+            role: ea_connector.destrole,
+            peer_obj: target_obj,
+            ea_connector: ea_connector,
+            cardinality: ea_connector.destcard,
+            obj: obj, obj_pkg_name: obj_pkg_name,
+            is_src: false
+          )
+        end
+
+        def build_start_attribute(ea_connector, obj, obj_pkg_name)
+          return nil if ea_connector.sourcerole.nil? || ea_connector.sourcerole.empty?
+
+          source_obj = find_object_by_id(ea_connector.start_object_id)
+          return nil unless source_obj
+
+          build_directional_attribute(
+            role: ea_connector.sourcerole,
+            peer_obj: source_obj,
+            ea_connector: ea_connector,
+            cardinality: ea_connector.sourcecard,
+            obj: obj, obj_pkg_name: obj_pkg_name
+          )
+        end
+
+        def build_directional_attribute(role:, peer_obj:, ea_connector:,
+                                        cardinality:, obj:, obj_pkg_name:,
+                                        is_src: true)
+          create_association_attribute(
+            name: role,
+            type: peer_obj.name,
+            type_xmi_id: peer_obj.ea_guid,
+            association_xmi_id: ea_connector.ea_guid,
+            cardinality: cardinality,
+            definition: ea_connector.notes,
+            gen_name: obj.name,
+            name_ns: obj_pkg_name,
+            type_ns: find_package_name(peer_obj.package_id),
+            is_src: is_src,
+          )
+        end
+
+        def build_cardinality(cardinality_str)
+          return nil unless cardinality_str && !cardinality_str.empty?
+
+          parsed = parse_cardinality(cardinality_str)
+          return nil unless parsed[:min] || parsed[:max]
+
+          Lutaml::Uml::Cardinality.new.tap do |card|
+            card.min = parsed[:min]
+            card.max = parsed[:max]
+          end
+        end
+
         def find_package_name(package_id)
           return nil if package_id.nil?