lutaml 0.10.8 → 0.10.10

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

data/lib/lutaml/uml/model_helpers.rb

@@ -2,20 +2,7 @@
 
 module Lutaml
   module Uml
-    # Shared helper methods for UML model objects.
-    # These methods are used across transformers, serializers, and presenters
-    # to avoid duplication of common model traversal and formatting logic.
     module ModelHelpers
-      # Normalize a stereotype value to a consistent Array format.
-      #
-      # @param stereotype [String, Array, nil, Symbol] The stereotype value
-      # @return [Array<String>] Array of stereotype strings
-      #
-      # @example
-      #   normalize_stereotypes(nil)                    # => []
-      #   normalize_stereotypes("enumeration")        # => ["enumeration"]
-      #   normalize_stereotypes(["a", "b"])           # => ["a", "b"]
-      #   normalize_stereotypes(:enumeration)         # => ["enumeration"]
       def normalize_stereotypes(stereotype)
         return [] if stereotype.nil?
 
@@ -27,51 +14,28 @@ module Lutaml
         end
       end
 
-      # Build a fully qualified name by walking the namespace chain of a UML element.
-      #
-      # @param uml_element [Lutaml::Uml::TopElement, Lutaml::Uml::Package] Any element with a namespace
-      # @return [String] Fully qualified name joined by '::'
-      #
-      # @example
-      #   qualified_name_for(class_in_package)  # => "ModelName::PackageName::ClassName"
       def qualified_name_for(uml_element)
-        return uml_element.name unless uml_element.respond_to?(:namespace)
-
         parts = []
         current = uml_element
 
         while current
           parts.unshift(current.name) if current.name
-          current = if current.respond_to?(:namespace) && current.namespace
-                      current.namespace
-                    else
-                      break
-                    end
+          current = current.namespace
         end
 
         parts.join("::")
       end
 
-      # Build a package-only namespace path (no class names).
-      #
-      # @param uml_element [Lutaml::Uml::TopElement, Lutaml::Uml::Package]
-      # @return [String] Package path joined by '::'
-      #
-      # @example
-      #   package_path_for(class_in_nested_package)  # => "ModelName::ParentPackage::ChildPackage"
       def package_path_for(uml_element)
-        return uml_element.name unless uml_element.respond_to?(:namespace)
-
         parts = []
         current = uml_element
 
         while current
           if current.is_a?(Lutaml::Uml::Package)
             parts.unshift(current.name) if current.name
-            current = current.namespace if current.respond_to?(:namespace)
+            current = current.namespace
           elsif current.is_a?(Lutaml::Uml::TopElement)
-            # Stop at the first TopElement (class, enum, etc.) — namespace above is package
-            current = current.namespace if current.respond_to?(:namespace)
+            current = current.namespace
           else
             break
           end
@@ -80,14 +44,6 @@ module Lutaml
         parts.join("::")
       end
 
-      # Extract the leaf class name from a fully-qualified class name or class object.
-      #
-      # @param uml_class [String, Class] A class name string or a Lutaml::Uml::* class instance
-      # @return [String] The leaf class name
-      #
-      # @example
-      #   class_type_for("Lutaml::Uml::Class")    # => "Class"
-      #   class_type_for(some_enum_object)          # => "Enumeration"
       def class_type_for(uml_class)
         case uml_class
         when String then uml_class.split("::").last
@@ -96,19 +52,11 @@ module Lutaml
         end
       end
 
-      # Format a cardinality object as a "min..max" string.
-      #
-      # @param cardinality [Lutaml::Uml::Cardinality, Hash, nil]
-      # @return [String, nil] Formatted cardinality string or nil
-      #
-      # @example
-      #   format_cardinality(Lutaml::Uml::Cardinality.new(min: 0, max: 5))  # => "0..5"
-      #   format_cardinality({min: 1, max: nil})                           # => "1..*"
       def format_cardinality(cardinality)
         return nil unless cardinality
 
-        min = cardinality.respond_to?(:min) ? cardinality.min : cardinality[:min]
-        max = cardinality.respond_to?(:max) ? cardinality.max : cardinality[:max]
+        min = cardinality.min
+        max = cardinality.max
         return nil if min.nil? && max.nil?
 
         min_str = min.nil? ? "0" : min.to_s
@@ -116,11 +64,6 @@ module Lutaml
         "#{min_str}..#{max_str}"
       end
 
-      # Parse a cardinality string or hash into a {min:, max:} hash.
-      #
-      # @param min [String, nil]
-      # @param max [String, nil]
-      # @return [Hash{Symbol => String, nil}] Hash with :min and :max keys
       def parse_cardinality(min, max)
         { min: min, max: max }
       end

data/lib/lutaml/uml/operation.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+require_relative "operation_parameter"
+
 module Lutaml
   module Uml
     class Operation < TopElement
       attribute :id, :string
       attribute :return_type, :string
       attribute :parameter_type, :string
+      attribute :is_static, :boolean, default: false
+      attribute :is_abstract, :boolean, default: false
+      attribute :owned_parameter, OperationParameter, collection: true,
+                                                      default: -> { [] }
 
       yaml do
         map "id", to: :id

data/lib/lutaml/uml/operation_parameter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Uml
+    class OperationParameter < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :type, :string
+      attribute :direction, :string, default: "in"
+
+      yaml do
+        map "name", to: :name
+        map "type", to: :type
+        map "direction", to: :direction
+      end
+    end
+  end
+end

data/lib/lutaml/uml/qualified_name.rb

@@ -65,8 +65,7 @@ module Lutaml
         return "" if @class_name.nil? || @class_name.empty?
 
         # Check if package path is empty
-        if @package_path.nil? ||
-            (@package_path.respond_to?(:empty?) && @package_path.empty?)
+        if @package_path.nil? || @package_path.empty?
           return @class_name
         end
 
@@ -105,7 +104,7 @@ module Lutaml
       #   qname.matches_glob?("Package1::*::ClassName") # => true
       def matches_glob?(pattern)
         # Create a full path for matching (package + class)
-        full_segments = if @package_path.respond_to?(:segments) &&
+        full_segments = if @package_path.is_a?(PackagePath) &&
             !@package_path.segments.empty?
                           @package_path.segments + [@class_name]
                         else
@@ -125,7 +124,7 @@ module Lutaml
       #   new_path = PackagePath.new("Package2")
       #   qname.with_package(new_path) # => QualifiedName("Package2::ClassName")
       def with_package(new_package_path)
-        if new_package_path.respond_to?(:empty?) && new_package_path.empty?
+        if new_package_path.empty?
           self.class.new(@class_name)
         else
           self.class.new("#{new_package_path}#{PackagePath::SEPARATOR}#{@class_name}")
@@ -148,7 +147,7 @@ module Lutaml
         return self if relative_path == @package_path
 
         # Otherwise create new qualified name with relative path
-        if relative_path.respond_to?(:empty?) && relative_path.empty?
+        if relative_path.empty?
           self.class.new(@class_name)
         else
           self.class.new("#{relative_path}#{PackagePath::SEPARATOR}#{@class_name}")

data/lib/lutaml/uml/top_element_attribute.rb

@@ -13,6 +13,10 @@ module Lutaml
       attribute :cardinality, Cardinality
       attribute :keyword, :string
       attribute :is_derived, :boolean, default: false
+      attribute :is_static, :boolean, default: false
+      attribute :is_read_only, :boolean, default: false
+      attribute :default, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
 
       attribute :definition, :string
       attribute :association, :string

data/lib/lutaml/uml/validation/document_structure_validator.rb

@@ -75,7 +75,7 @@ module Lutaml
         # @param path [String] Package path for error reporting
         # @return [void]
         def validate_collection(package, attribute, path) # rubocop:disable Metrics/MethodLength
-          value = package.send(attribute)
+          value = package.public_send(attribute)
           unless value.nil? || value.is_a?(Array)
             result.add_error(
               category: :invalid_structure,
@@ -175,7 +175,7 @@ module Lutaml
           name_counts = Hash.new(0)
 
           collection.each do |entity|
-            next unless entity.respond_to?(:name) && entity.name
+            next unless entity.name
 
             name_counts[entity.name] += 1
           end
@@ -212,10 +212,10 @@ module Lutaml
 
           # Check attribute type references
           all_classes.each do |cls, path|
-            next unless cls.respond_to?(:attributes)
+            next unless cls.is_a?(Lutaml::Uml::Class) || cls.is_a?(Lutaml::Uml::DataType)
 
             (cls.attributes || []).each do |attr|
-              next unless attr.respond_to?(:type) && attr.type
+              next unless attr.type
               next if primitive_type?(attr.type)
               next if valid_types.include?(attr.type)
 

data/lib/lutaml/uml_repository/class_lookup_index.rb

@@ -18,7 +18,7 @@ module Lutaml
 
         classes.each do |klass|
           @by_xmi_id[klass.xmi_id] = klass if klass.xmi_id
-          if klass.respond_to?(:ea_object_id) && klass.ea_object_id
+          if klass.class.attributes.key?(:ea_object_id) && klass.ea_object_id
             @by_object_id[klass.ea_object_id] = klass
           end
         end

data/lib/lutaml/uml_repository/exporters/json_exporter.rb

@@ -228,7 +228,7 @@ module Lutaml
         # @param klass [Object] The class object
         # @return [Array<Hash>] Array of operation hashes
         def serialize_operations(klass)
-          return [] unless klass.respond_to?(:operations) && klass.operations
+          return [] unless klass.is_a?(Lutaml::Uml::Classifier) && klass.operations
 
           klass.operations.map do |op|
             {

data/lib/lutaml/uml_repository/exporters/markdown/class_page_builder.rb

@@ -55,7 +55,7 @@ module Lutaml
           end
 
           def build_definition_section(klass)
-            return "" unless klass.respond_to?(:definition) && klass.definition
+            return "" unless klass.definition
 
             "## Description\n\n#{klass.definition}\n\n"
           end
@@ -105,7 +105,7 @@ module Lutaml
           end
 
           def build_operations_section(klass)
-            return "" unless klass.respond_to?(:operations) && klass.operations&.any?
+            return "" unless klass.operations&.any?
 
             content = "## Operations\n\n"
             content += "| Name | Return Type | Visibility |\n"

data/lib/lutaml/uml_repository/index_builder.rb

@@ -56,13 +56,13 @@ module Lutaml
       def self.build_package_paths(document)
         builder = new(document)
         builder.build_package_path_index
-        builder.instance_variable_get(:@package_paths).freeze
+        builder.package_paths.freeze
       end
 
       def self.build_package_to_path(document)
         builder = new(document)
         builder.build_package_path_index
-        builder.instance_variable_get(:@package_to_path).freeze
+        builder.package_to_path.freeze
       end
 
       # Build qualified names index
@@ -72,19 +72,19 @@ module Lutaml
       def self.build_qualified_names(document)
         builder = new(document)
         builder.build_qualified_name_index
-        builder.instance_variable_get(:@qualified_names).freeze
+        builder.qualified_names.freeze
       end
 
       def self.build_class_to_qname(document)
         builder = new(document)
         builder.build_qualified_name_index
-        builder.instance_variable_get(:@class_to_qname).freeze
+        builder.class_to_qname.freeze
       end
 
       def self.build_classes(document)
         builder = new(document)
         builder.build_qualified_name_index
-        builder.instance_variable_get(:@classes).freeze
+        builder.classes.freeze
       end
 
       def self.build_associations(document)
@@ -93,7 +93,7 @@ module Lutaml
         # class-level associations
         builder.build_qualified_name_index
         builder.build_association_index
-        builder.instance_variable_get(:@associations).freeze
+        builder.associations.freeze
       end
 
       # Build stereotypes index
@@ -103,7 +103,7 @@ module Lutaml
       def self.build_stereotypes(document)
         builder = new(document)
         builder.build_stereotype_index
-        builder.instance_variable_get(:@stereotypes).freeze
+        builder.stereotypes.freeze
       end
 
       # Build inheritance graph index
@@ -113,15 +113,13 @@ module Lutaml
       # @return [Hash] Frozen hash mapping parent qnames to child qnames
       def self.build_inheritance_graph(document, indexes)
         builder = new(document)
-        # If qualified_names index is provided, use it
         if indexes && indexes[:qualified_names]
-          builder.instance_variable_set(:@qualified_names,
-                                        indexes[:qualified_names])
+          builder.qualified_names = indexes[:qualified_names]
         else
           builder.build_qualified_name_index
         end
         builder.build_inheritance_graph_index
-        builder.instance_variable_get(:@inheritance_graph).freeze
+        builder.inheritance_graph.freeze
       end
 
       # Build diagram index
@@ -131,15 +129,13 @@ module Lutaml
       # @return [Hash] Frozen hash mapping package IDs to Diagram objects
       def self.build_diagram_index(document, indexes)
         builder = new(document)
-        # If package_paths index is provided, use it
         if indexes && indexes[:package_paths]
-          builder.instance_variable_set(:@package_paths,
-                                        indexes[:package_paths])
+          builder.package_paths = indexes[:package_paths]
         else
           builder.build_package_path_index
         end
         builder.build_diagram_index
-        builder.instance_variable_get(:@diagram_index).freeze
+        builder.diagram_index.freeze
       end
 
       def initialize(document)
@@ -157,6 +153,10 @@ module Lutaml
         @package_to_classes = {}
       end
 
+      attr_accessor :package_paths, :qualified_names
+      attr_reader :package_to_path, :class_to_qname, :classes, :associations,
+                  :stereotypes, :inheritance_graph, :diagram_index
+
       # Build all indexes and return them as a frozen hash
       #
       # @return [Hash] Frozen hash containing all indexes

data/lib/lutaml/uml_repository/package_exporter.rb

@@ -277,15 +277,13 @@ module Lutaml
       # @param klass [Object] The class object
       # @return [Array<Hash>] List of attributes
       def build_attributes_list(klass)
-        return [] unless klass.respond_to?(:attributes) && klass.attributes
+        return [] unless klass.is_a?(Lutaml::Uml::Classifier) && klass.attributes
 
         klass.attributes.map do |attr|
           {
             "name" => attr.name,
             "type" => attr.type,
-            "visibility" => if attr.respond_to?(:visibility)
-                              attr.visibility
-                            end,
+            "visibility" => attr.visibility,
           }.compact
         end
       end
@@ -316,7 +314,7 @@ module Lutaml
       def count_all_attributes
         total = 0
         @repository.indexes[:qualified_names].each_value do |klass|
-          if klass.respond_to?(:attributes) && klass.attributes
+          if klass.is_a?(Lutaml::Uml::Classifier) && klass.attributes
             total += klass.attributes.size
           end
         end

data/lib/lutaml/uml_repository/package_loader.rb

@@ -147,11 +147,11 @@ module Lutaml
       # @raise [RuntimeError] If document is missing or format is unknown
       def self.load_document(zip, metadata) # rubocop:disable Metrics/MethodLength
         # Handle both PackageMetadata object and Hash (backward compatibility)
-        format = if metadata.respond_to?(:serialization_format)
-                   metadata.serialization_format
-                 else
+        format = if metadata.is_a?(Hash)
                    metadata["serialization_format"] ||
                      metadata[:serialization_format]
+                 else
+                   metadata.serialization_format
                  end
 
         case format.to_s

data/lib/lutaml/uml_repository/queries/association_query.rb

@@ -57,13 +57,13 @@ module Lutaml
           results = []
 
           # Get owned associations from the class itself
-          if klass.respond_to?(:associations) && klass.associations
+          if (klass.is_a?(Lutaml::Uml::Class) || klass.is_a?(Lutaml::Uml::DataType)) && klass.associations
             results.concat(klass.associations)
           end
 
           # Get associations from document level unless owned_only
           if !owned_only &&
-              document.respond_to?(:associations) && document.associations
+              document.is_a?(Lutaml::Uml::Document) && document.associations
             document_associations = document.associations.select do |assoc|
               match_association?(assoc, class_name, direction)
             end

data/lib/lutaml/uml_repository/queries/inheritance_query.rb

@@ -36,7 +36,7 @@ module Lutaml
         def supertype(class_or_qname) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
           klass = resolve_class(class_or_qname)
           return nil unless klass
-          return nil unless klass.respond_to?(:generalization)
+          return nil unless klass.is_a?(Lutaml::Uml::Class)
           return nil unless klass.generalization
 
           parent_name = extract_parent_name(klass.generalization)
@@ -230,7 +230,7 @@ module Lutaml
 
           # Try as xmi_id - search in qualified_names
           indexes[:qualified_names].each_value do |entity|
-            next unless entity.respond_to?(:xmi_id)
+            next unless entity.xmi_id
 
             return entity if entity.xmi_id == class_or_id
           end
@@ -280,22 +280,18 @@ module Lutaml
         # @param generalization [Lutaml::Uml::Generalization]
         # Generalization object
         # @return [String, nil] Parent class name
-        def extract_parent_name(generalization) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def extract_parent_name(generalization)
           return nil unless generalization
+          return nil unless generalization.is_a?(Lutaml::Uml::Generalization)
 
-          # Check for general attribute (could be a string or object)
-          if generalization.respond_to?(:general)
-            parent = generalization.general
-            return parent.name if parent.respond_to?(:name)
-            return parent.to_s if parent
-          end
+          parent = generalization.general
+          if parent
+            return parent.name if parent.is_a?(Lutaml::Uml::Generalization) && parent.name
 
-          # Check for name attribute directly
-          if generalization.respond_to?(:name) && generalization.name
-            return generalization.name
+            return parent.to_s
           end
 
-          nil
+          generalization.name if generalization.name
         end
 
         # Resolve a class name to its qualified name

data/lib/lutaml/uml_repository/queries/search_query.rb

@@ -129,8 +129,8 @@ module Lutaml
 
             # Check fields for match
             fields.each do |field|
-              if entity.respond_to?(field) &&
-                  entity.send(field)&.match?(pattern)
+              if entity.class.attributes.key?(field) &&
+                  entity.public_send(field)&.match?(pattern)
 
                 match_field = field
                 qualified_name = qname
@@ -157,7 +157,7 @@ module Lutaml
           matched_entities = indexes[:stereotypes]
             .filter_map do |_stereotype, entities|
             entities.select do |entity|
-              entity.respond_to?(:stereotype) &&
+              entity.is_a?(Lutaml::Uml::Classifier) &&
                 Array(entity.stereotype).any? { |s| s&.match?(pattern) }
             end.uniq
           end.uniq.flatten
@@ -218,7 +218,7 @@ module Lutaml
           )
 
           indexes[:qualified_names].filter_map do |class_qname, entity| # rubocop:disable Metrics/BlockLength
-            next unless entity.respond_to?(:attributes) && entity.attributes
+            next unless entity.is_a?(Lutaml::Uml::Classifier) && entity.attributes
 
             match_field = nil
             match_attr = nil
@@ -227,8 +227,8 @@ module Lutaml
             entity.attributes.each do |attr|
               # Check attribute for match
               fields.each do |field|
-                if attr.respond_to?(field) &&
-                    attr.send(field)&.match?(pattern)
+                if attr.class.attributes.key?(field) &&
+                    attr.public_send(field)&.match?(pattern)
 
                   match_attr = attr
                   match_field = field
@@ -294,7 +294,7 @@ module Lutaml
             match_field = nil
 
             fields.each do |field|
-              if assoc.respond_to?(field) && assoc.send(field)&.match?(pattern)
+              if assoc.class.attributes.key?(field) && assoc.public_send(field)&.match?(pattern)
                 match_field = field
               end
             end

data/lib/lutaml/uml_repository/query_dsl/conditions/hash_condition.rb

@@ -51,9 +51,9 @@ module Lutaml
           # @param value [Object] The expected value
           # @return [Boolean] true if condition matches
           def matches_condition?(obj, key, value)
-            return false unless obj.respond_to?(key)
+            return false unless obj.class.attributes.key?(key.to_sym)
 
-            actual_value = obj.send(key)
+            actual_value = obj.public_send(key)
             compare_values(actual_value, value)
           end
 

data/lib/lutaml/uml_repository/query_dsl/order.rb

@@ -64,9 +64,9 @@ module Lutaml
         # @param obj [Object] The object to extract value from
         # @return [Object] The value to use for sorting
         def extract_sort_value(obj)
-          return "" unless obj.respond_to?(@field)
+          return "" unless obj.class.attributes.key?(@field.to_sym)
 
-          value = obj.send(@field)
+          value = obj.public_send(@field)
           normalize_value(value)
         end
 

data/lib/lutaml/uml_repository/query_dsl/query_builder.rb

@@ -236,7 +236,7 @@ module Lutaml
         #
         # @return [Array<Lutaml::Uml::Class>] Array of class objects
         def fetch_classes
-          indexes = @repository.instance_variable_get(:@indexes)
+          indexes = @repository.indexes
           qnames_index = indexes[:qualified_names] || {}
 
           qnames_index.values.select do |obj|
@@ -250,7 +250,7 @@ module Lutaml
         #
         # @return [Array<Lutaml::Uml::Package>] Array of package objects
         def fetch_packages
-          indexes = @repository.instance_variable_get(:@indexes)
+          indexes = @repository.indexes
           package_paths_index = indexes[:package_paths] || {}
           package_paths_index.values
         end