lutaml 0.10.9 → 0.10.11

data/lib/lutaml/model_transformations/format_registry.rb

@@ -63,7 +63,7 @@ module Lutaml
       # @return [void]
       def auto_register_from_parser(parser_class)
         supported_extensions = ""
-        if parser_class.new.respond_to?(:supported_extensions)
+        if parser_class.method_defined?(:supported_extensions)
           supported_extensions = parser_class.new.supported_extensions
         end
         register(supported_extensions, parser_class)
@@ -255,7 +255,7 @@ module Lutaml
 
           # Check header match for content patterns
           @parsers.each do |ext, parser_class|
-            if parser_class.new.respond_to? :content_patterns
+            if parser_class.method_defined?(:content_patterns)
               parser_klass = parser_class.new
               parser_klass.content_patterns.each do |pattern|
                 if header.match?(pattern)

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

@@ -107,7 +107,7 @@ module Lutaml
           extension = File.extname(file_path).downcase
           return true if supported_extensions.include?(extension)
 
-          if respond_to?(:content_patterns) && File.exist?(file_path)
+          if self.class.method_defined?(:content_patterns) && File.exist?(file_path)
             File.open(file_path, "rb") do |file|
               header = file.read(1024) # Read first 1KB
               return false if header.nil? || header.empty?

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

@@ -269,16 +269,16 @@ module Lutaml
         # @return [void]
         def post_process_qea_document(document, file_path)
           # Set QEA-specific source information
-          if document.respond_to?(:source_file=)
+          if document.class.method_defined?(:source_file=)
             document.source_file = file_path
           end
 
-          if document.respond_to?(:source_format=)
+          if document.class.method_defined?(:source_format=)
             document.source_format = "QEA"
           end
 
           # Store database statistics
-          if document.respond_to?(:database_stats=)
+          if document.class.method_defined?(:database_stats=)
             document.database_stats = @database_stats
           end
         end
@@ -301,12 +301,10 @@ module Lutaml
           }
 
           # Store metadata using various approaches
-          if document.respond_to?(:parsing_metadata=)
+          if document.class.method_defined?(:parsing_metadata=)
             document.parsing_metadata = metadata
-          elsif document.respond_to?(:metadata=)
+          elsif document.class.method_defined?(:metadata=)
             document.metadata = metadata
-          else
-            document.instance_variable_set(:@qea_metadata, metadata)
           end
         end
 

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

@@ -138,12 +138,12 @@ module Lutaml
         # @return [void]
         def post_process_xmi_document(document, file_path)
           # Set source file information
-          if document.respond_to?(:source_file=)
+          if document.class.method_defined?(:source_file=)
             document.source_file = file_path
           end
 
           # Add timestamp
-          if document.respond_to?(:parsed_at=)
+          if document.class.method_defined?(:parsed_at=)
             document.parsed_at = Time.now
           end
 
@@ -165,13 +165,8 @@ module Lutaml
             options: @options,
           }
 
-          # Store metadata if document supports it
-          if document.respond_to?(:parsing_metadata=)
+          if document.class.method_defined?(:parsing_metadata=)
             document.parsing_metadata = metadata
-          elsif document.respond_to?(:instance_variable_set)
-            # Store in custom attribute if available
-            document.instance_variable_set(:@parsing_metadata,
-                                           metadata)
           end
         end
 

data/lib/lutaml/model_transformations/transformation_engine.rb

@@ -256,7 +256,7 @@ module Lutaml
         @format_registry.all_parsers.each_value do |parser_class|
           # Try to create instance to validate
           parser = parser_class.new(configuration: @configuration)
-          if parser.respond_to?(:parse)
+          if parser.class.method_defined?(:parse)
             results[:parsers_loaded] += 1
           else
             results[:parser_errors] << "Parser #{parser_class} does not " \

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

@@ -238,7 +238,7 @@ module Lutaml
         # @param valid_ids [Set<String>] Set of valid xmi_ids
         # @return [Boolean] True if valid or nil
         def check_association_end_valid?(assoc, attr, valid_ids)
-          value = assoc.send(attr)
+          value = assoc.public_send(attr)
           return true if value.nil?
 
           valid_ids.include?(value)
@@ -250,14 +250,14 @@ module Lutaml
         # @param valid_ids [Set<String>] Set of valid xmi_ids
         # @param warnings [Array<String>] Warning accumulator
         def add_invalid_end_warning(assoc, attr, valid_ids, warnings) # rubocop:disable Metrics/MethodLength
-          value = assoc.send(attr)
+          value = assoc.public_send(attr)
           return if value.nil?
 
           unless valid_ids.include?(value)
             # Get the corresponding name attribute for better error messages
             name_attr = attr.to_s.gsub("_xmi_id", "").to_sym
             name_value = begin
-              assoc.send(name_attr)
+              assoc.public_send(name_attr)
             rescue StandardError
               nil
             end

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

@@ -244,7 +244,8 @@ module Lutaml
         def collect_package_associations(package, associations) # rubocop:disable Metrics/CyclomaticComplexity
           # Collect from classes in this package
           package.classes&.each do |klass|
-            if klass.respond_to?(:associations) && klass.associations
+            if (klass.is_a?(Lutaml::Uml::Class) ||
+                klass.is_a?(Lutaml::Uml::DataType)) && klass.associations
               associations.concat(klass.associations)
             end
           end

data/lib/lutaml/qea/lookup_indexes.rb

@@ -17,12 +17,12 @@ module Lutaml
       def build_group_index(collection, method, single: false)
         if single
           collection.each_with_object({}) do |item, hash|
-            key = item.send(method)
+            key = item.public_send(method)
             hash[key] = item if key
           end
         else
           collection.each_with_object({}) do |item, hash|
-            key = item.send(method)
+            key = item.public_send(method)
             (hash[key] ||= []) << item if key
           end
         end

data/lib/lutaml/qea/models/base_model.rb

@@ -25,7 +25,7 @@ module Lutaml
         # Returns the primary key value for this instance
         # @return [Object] the primary key value
         def primary_key
-          send(self.class.primary_key_column)
+          public_send(self.class.primary_key_column)
         end
 
         # Create instance from database row hash

data/lib/lutaml/qea/repositories/base_repository.rb

@@ -57,7 +57,7 @@ module Lutaml
         # @param id [Object] key value
         # @return [Object, nil] The record or nil if not found
         def find_by_key(key, id)
-          @records.find { |record| record.send(key) == id }
+          @records.find { |record| record.public_send(key) == id }
         end
 
         # Filter records by conditions
@@ -79,7 +79,7 @@ module Lutaml
           elsif conditions.is_a?(Hash)
             @records.select do |record|
               conditions.all? do |attr, value|
-                record.respond_to?(attr) && record.send(attr) == value
+                record.public_send(attr) == value
               end
             end
           else
@@ -150,8 +150,8 @@ module Lutaml
         #   # => [{id: 1, name: "Test"}, {id: 2, name: "Other"}]
         def pluck(*attributes)
           @records.map do |record|
-            attributes.each_with_object({}) do |attr, hash|
-              hash[attr] = record.send(attr) if record.respond_to?(attr)
+            attributes.to_h do |attr|
+              [attr, record.public_send(attr)]
             end
           end
         end
@@ -165,7 +165,7 @@ module Lutaml
         #   repository.group_by(:type)
         #   # => {"Class" => [obj1, obj2], "Interface" => [obj3]}
         def group_by(attribute)
-          @records.group_by { |record| record.send(attribute) }
+          @records.group_by { |record| record.public_send(attribute) }
         end
 
         # Sort records by an attribute
@@ -178,7 +178,7 @@ module Lutaml
         #   repository.order_by(:name)
         #   repository.order_by(:created_at, :desc)
         def order_by(attribute, order = :asc)
-          sorted = @records.sort_by { |record| record.send(attribute) }
+          sorted = @records.sort_by { |record| record.public_send(attribute) }
           order == :desc ? sorted.reverse : sorted
         end
 
@@ -191,7 +191,7 @@ module Lutaml
         #   repository.distinct(:type)
         #   # => ["Class", "Interface", "Component"]
         def distinct(attribute)
-          @records.map { |record| record.send(attribute) }.uniq
+          @records.map { |record| record.public_send(attribute) }.uniq
         end
 
         # Check if repository is empty

data/lib/lutaml/qea/validation/base_validator.rb

@@ -122,7 +122,9 @@ module Lutaml
           collection = get_collection_for_table(table)
           return false unless collection
 
-          collection.any? { |record| record.send(id_column) == reference_id }
+          collection.any? do |record|
+            record.public_send(id_column) == reference_id
+          end
         end
 
         # Maps table names to their corresponding collections in Database
@@ -207,7 +209,10 @@ module Lutaml
         # @param value [Object] Value to check
         # @return [Boolean]
         def present?(value)
-          !value.nil? && (value.respond_to?(:empty?) ? !value.empty? : true)
+          return false if value.nil?
+          return !value.empty? if value.is_a?(String) || value.is_a?(Array)
+
+          true
         end
 
         # Finds entity name from database
@@ -223,8 +228,8 @@ module Lutaml
           collection = get_collection_for_table(table)
           return nil unless collection
 
-          record = collection.find { |r| r.send(id_column) == id }
-          record&.send(name_column)
+          record = collection.find { |r| r.public_send(id_column) == id }
+          record&.public_send(name_column)
         end
 
         # Validates a collection of entities

data/lib/lutaml/qea/validation/validation_engine.rb

@@ -223,11 +223,7 @@ module Lutaml
           # Note: Use document entities for primary validation
           if @database
             context[:db_packages] = @database.packages || []
-            context[:db_objects] = if @database.objects.respond_to?(:all)
-                                     @database.objects.all
-                                   else
-                                     @database.objects || []
-                                   end
+            context[:db_objects] = @database.objects.all
             context[:attributes] = @database.attributes || []
             context[:operations] = @database.operations || []
             context[:connectors] = @database.connectors || []

data/lib/lutaml/qea/verification/document_normalizer.rb

@@ -73,7 +73,7 @@ module Lutaml
         # Process packages recursively to remove XMI IDs
         def process_packages(packages) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
           packages.each do |package|
-            package.xmi_id = nil if package.respond_to?(:xmi_id=)
+            package.xmi_id = nil
             process_classes(package.classes) if package.classes
             process_enums(package.enums) if package.enums
             process_data_types(package.data_types) if package.data_types
@@ -84,23 +84,23 @@ module Lutaml
         # Process classes to remove XMI IDs
         def process_classes(classes) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           classes.each do |klass|
-            klass.xmi_id = nil if klass.respond_to?(:xmi_id=)
+            klass.xmi_id = nil
 
             # Remove XMI IDs from attributes
             klass.attributes&.each do |attr|
-              attr.xmi_id = nil if attr.respond_to?(:xmi_id=)
+              attr.xmi_id = nil
             end
 
             # Remove XMI IDs from operations
             klass.operations&.each do |op|
-              op.xmi_id = nil if op.respond_to?(:xmi_id=)
+              op.xmi_id = nil
               op.parameters&.each do |param|
-                param.xmi_id = nil if param.respond_to?(:xmi_id=)
+                param.xmi_id = nil if param.class.attributes.key?(:xmi_id)
               end
             end
 
             # Process nested classes
-            if klass.respond_to?(:classes) && klass.classes
+            if klass.is_a?(Lutaml::Uml::Package) && klass.classes
               process_classes(klass.classes)
             end
           end
@@ -109,11 +109,11 @@ module Lutaml
         # Process associations to remove XMI IDs
         def process_associations(associations)
           associations.each do |assoc|
-            assoc.xmi_id = nil if assoc.respond_to?(:xmi_id=)
-            if assoc.respond_to?(:owner_end_xmi_id=)
+            assoc.xmi_id = nil
+            if assoc.owner_end_xmi_id
               assoc.owner_end_xmi_id = nil
             end
-            if assoc.respond_to?(:member_end_xmi_id=)
+            if assoc.member_end_xmi_id
               assoc.member_end_xmi_id = nil
             end
           end
@@ -122,14 +122,14 @@ module Lutaml
         # Process enums to remove XMI IDs
         def process_enums(enums)
           enums.each do |enum|
-            enum.xmi_id = nil if enum.respond_to?(:xmi_id=)
+            enum.xmi_id = nil
           end
         end
 
         # Process data types to remove XMI IDs
         def process_data_types(data_types)
           data_types.each do |dt|
-            dt.xmi_id = nil if dt.respond_to?(:xmi_id=)
+            dt.xmi_id = nil
           end
         end
 

data/lib/lutaml/qea/verification/element_comparator.rb

@@ -52,25 +52,19 @@ module Lutaml
           end
 
           # Compare is_abstract
-          if xmi_class.respond_to?(:is_abstract) &&
-              qea_class.respond_to?(:is_abstract) &&
-              xmi_class.is_abstract != qea_class.is_abstract
+          if xmi_class.is_abstract != qea_class.is_abstract
             differences << "is_abstract: #{xmi_class.is_abstract} " \
                            "vs #{qea_class.is_abstract}"
           end
 
           # Compare type
-          if xmi_class.respond_to?(:type) &&
-              qea_class.respond_to?(:type) &&
-              normalize_value(xmi_class.type) != normalize_value(qea_class.type)
+          if normalize_value(xmi_class.type) != normalize_value(qea_class.type)
             differences << "type: '#{xmi_class.type}' vs '#{qea_class.type}'"
           end
 
           # Compare modifier
-          if xmi_class.respond_to?(:modifier) &&
-              qea_class.respond_to?(:modifier) &&
-              normalize_value(xmi_class.modifier) !=
-                  normalize_value(qea_class.modifier)
+          if normalize_value(xmi_class.modifier) !=
+              normalize_value(qea_class.modifier)
             differences << "modifier: '#{xmi_class.modifier}' " \
                            "vs '#{qea_class.modifier}'"
           end
@@ -105,27 +99,22 @@ module Lutaml
           end
 
           # Compare type
-          if xmi_attr.respond_to?(:type) &&
-              qea_attr.respond_to?(:type) &&
-              normalize_value(xmi_attr.type) !=
-                  normalize_value(qea_attr.type)
+          if normalize_value(xmi_attr.type) !=
+              normalize_value(qea_attr.type)
             differences << "type: '#{xmi_attr.type}' vs '#{qea_attr.type}'"
           end
 
           # Compare visibility
-          if xmi_attr.respond_to?(:visibility) &&
-              qea_attr.respond_to?(:visibility) &&
-              normalize_value(xmi_attr.visibility) !=
-                  normalize_value(qea_attr.visibility)
+          if normalize_value(xmi_attr.visibility) !=
+              normalize_value(qea_attr.visibility)
             differences << "visibility: '#{xmi_attr.visibility}' " \
                            "vs '#{qea_attr.visibility}'"
           end
 
           # Compare cardinality if present
-          if xmi_attr.respond_to?(:cardinality) &&
-              qea_attr.respond_to?(:cardinality)
-            xmi_card = xmi_attr.cardinality
-            qea_card = qea_attr.cardinality
+          xmi_card = xmi_attr.cardinality
+          qea_card = qea_attr.cardinality
+          if xmi_card || qea_card
             if xmi_card && qea_card
               unless cardinalities_equal?(xmi_card, qea_card)
                 differences << "cardinality: #{format_cardinality(xmi_card)} " \
@@ -157,19 +146,15 @@ module Lutaml
           end
 
           # Compare return type
-          if xmi_op.respond_to?(:return_type) &&
-              qea_op.respond_to?(:return_type) &&
-              normalize_value(xmi_op.return_type) !=
-                  normalize_value(qea_op.return_type)
+          if normalize_value(xmi_op.return_type) !=
+              normalize_value(qea_op.return_type)
             differences << "return_type: '#{xmi_op.return_type}' " \
                            "vs '#{qea_op.return_type}'"
           end
 
           # Compare visibility
-          if xmi_op.respond_to?(:visibility) &&
-              qea_op.respond_to?(:visibility) &&
-              normalize_value(xmi_op.visibility) !=
-                  normalize_value(qea_op.visibility)
+          if normalize_value(xmi_op.visibility) !=
+              normalize_value(qea_op.visibility)
             differences << "visibility: '#{xmi_op.visibility}' " \
                            "vs '#{qea_op.visibility}'"
           end
@@ -273,32 +258,18 @@ module Lutaml
         end
 
         # Check if cardinalities are equal
-        def cardinalities_equal?(card1, card2) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def cardinalities_equal?(card1, card2)
           return true if card1.nil? && card2.nil?
           return false if card1.nil? || card2.nil?
 
-          min_equal = (
-            card1.min || (card1.respond_to?(:min_value) && card1.min_value)
-          ) == (
-            card2.min || (card2.respond_to?(:min_value) && card2.min_value)
-          )
-          max_equal = (
-            card1.max || (card1.respond_to?(:max_value) && card1.max_value)
-          ) == (
-            card2.max || (card2.respond_to?(:max_value) && card2.max_value)
-          )
-
-          min_equal && max_equal
+          card1.min == card2.min && card1.max == card2.max
         end
 
         # Format cardinality for display
         def format_cardinality(card)
           return "nil" if card.nil?
 
-          min = card.min || (card.respond_to?(:min_value) && card.min_value)
-          max = card.max || (card.respond_to?(:max_value) && card.max_value)
-
-          "#{min}..#{max}"
+          "\#{card.min}..\#{card.max}"
         end
       end
     end

data/lib/lutaml/qea/verification/structure_matcher.rb

@@ -222,7 +222,7 @@ module Lutaml
         def index_by_name(collection)
           index = {}
           collection.each do |element|
-            next unless element.respond_to?(:name) && element.name
+            next unless element.name
 
             index[element.name] = element
           end
@@ -243,10 +243,10 @@ module Lutaml
 
         # Build operation signature for matching
         def build_operation_signature(operation)
-          return operation.name unless operation.respond_to?(:parameters)
+          return operation.name unless operation.owned_parameter
 
-          param_types = (operation.parameters || []).map do |param|
-            param.respond_to?(:type) ? param.type : "unknown"
+          param_types = operation.owned_parameter.map do |param|
+            param.type || "unknown"
           end.join(",")
 
           "#{operation.name}(#{param_types})"

data/lib/lutaml/uml/association_generalization.rb

@@ -6,6 +6,7 @@ module Lutaml
       attribute :id, :string
       attribute :type, :string
       attribute :general, :string
+      attribute :parent_object_id, :string
 
       yaml do
         map "id", to: :id

data/lib/lutaml/uml/class.rb

@@ -13,7 +13,6 @@ module Lutaml
     class Class < Classifier
       attribute :nested_classifier, :string, collection: true,
                                              default: -> { [] }
-      attribute :is_abstract, :boolean, default: false
       attribute :stereotype, :string, collection: true, default: -> { [] }
       attribute :type, :string
       attribute :attributes, TopElementAttribute, collection: true

data/lib/lutaml/uml/classifier.rb

@@ -2,6 +2,7 @@
 
 require_relative "top_element"
 require_relative "association_generalization"
+require_relative "operation"
 
 module Lutaml
   module Uml
@@ -9,6 +10,8 @@ module Lutaml
       attribute :association_generalization,
                 ::Lutaml::Uml::AssociationGeneralization,
                 collection: true, default: -> { [] }
+      attribute :operations, Operation, collection: true, default: -> { [] }
+      attribute :is_abstract, :boolean, default: false
 
       yaml do
         map "generalization", to: :association_generalization

data/lib/lutaml/uml/data_type.rb

@@ -11,7 +11,6 @@ module Lutaml
     class DataType < Classifier
       attribute :nested_classifier, :string, collection: true,
                                              default: -> { [] }
-      attribute :is_abstract, :boolean, default: false
       attribute :type, :string
       attribute :attributes, TopElementAttribute, collection: true
       attribute :modifier, :string

data/lib/lutaml/uml/has_attributes.rb

@@ -5,7 +5,7 @@ module Lutaml
     module HasAttributes
       def update_attributes(attributes = {})
         attributes.to_h.each do |name, value|
-          value = value.str if value.respond_to?(:str)
+          value = value.str if value.is_a?(Parslet::Slice)
           public_send(:"#{name}=", value)
         end
       end

data/lib/lutaml/uml/has_members.rb

@@ -21,7 +21,7 @@ module Lutaml
       private
 
       def association_type(type)
-        return type if respond_to?(:"#{type}=")
+        return type if self.class.attributes.key?(type.to_sym)
 
         raise(UnknownMemberTypeError, "Unknown member type: #{type}")
       end

data/lib/lutaml/uml/inheritance_walker.rb

@@ -31,7 +31,7 @@ module Lutaml
       #     puts "#{'  ' * (level - 1)}Parent #{level}: #{parent.name}"
       #   end
       def walk(klass)
-        return [] unless klass.respond_to?(:generalization) && klass.generalization
+        return [] unless klass.is_a?(Lutaml::Uml::Class) && klass.generalization
 
         ancestors = []
         @visited.clear
@@ -69,12 +69,12 @@ module Lutaml
       # Uses a trail set for cycle detection (avoids Set mutation issues across calls).
       def collect_ancestors(klass, result, trail = [])
         return [] if trail.include?(klass.xmi_id) # cycle guard
-        return [] unless klass.respond_to?(:generalization) && klass.generalization
+        return [] unless klass.is_a?(Lutaml::Uml::Class) && klass.generalization
 
         trail = trail.dup
         trail << klass.xmi_id
 
-        general_id = klass.generalization.respond_to?(:general_id) ? klass.generalization.general_id : nil
+        general_id = klass.generalization.general_id
         parent = general_id ? find_class_by_id(general_id) : nil
 
         return [] unless parent
@@ -85,7 +85,7 @@ module Lutaml
 
       def find_class_by_id(xmi_id)
         @repository.indexes&.dig(:qualified_names, xmi_id) ||
-          @repository.send(:classes_index)&.find { |c| c.xmi_id == xmi_id }
+          @repository.classes_index&.find { |c| c.xmi_id == xmi_id }
       end
     end
   end