lutaml 0.10.18 → 0.11.2

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

@@ -1,387 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    module Validation
-      # Validates UML document tree structure
-      # This validator ensures proper nesting, no duplicate names within same
-      # parent, and valid type references in the transformed UML tree
-      class DocumentStructureValidator < Qea::Validation::BaseValidator
-        def validate
-          return unless document
-
-          validate_package_hierarchy(document.packages || [])
-          validate_no_duplicate_names
-          validate_type_references
-        end
-
-        private
-
-        # Validates package hierarchy recursively
-        #
-        # @param packages [Array<Lutaml::Uml::Package>] Packages to validate
-        # @param parent_path [String] Parent package path for context
-        # @return [void]
-        def validate_package_hierarchy(packages, parent_path = "") # rubocop:disable Metrics/MethodLength
-          packages.each do |package|
-            current_path = if parent_path.empty?
-                             package.name
-                           else
-                             "#{parent_path}::#{package.name}"
-                           end
-
-            # Validate package structure
-            validate_package_structure(package, current_path)
-
-            # Recursively validate child packages
-            if package.packages && !package.packages.empty?
-              validate_package_hierarchy(package.packages, current_path)
-            end
-          end
-        end
-
-        # Validates individual package structure
-        #
-        # @param package [Lutaml::Uml::Package] Package to validate
-        # @param path [String] Package path for error reporting
-        # @return [void]
-        def validate_package_structure(package, path) # rubocop:disable Metrics/MethodLength
-          # Check for required fields
-          unless present?(package.name)
-            result.add_error(
-              category: :invalid_structure,
-              entity_type: :package,
-              entity_id: package.xmi_id || "unknown",
-              entity_name: "Unnamed",
-              field: "name",
-              message: "Package at path '#{path}' has no name",
-            )
-          end
-
-          # Validate children collections are arrays
-          validate_collection(package, :classes, path)
-          validate_collection(package, :enums, path)
-          validate_collection(package, :data_types, path)
-          validate_collection(package, :packages, path)
-          validate_collection(package, :diagrams, path)
-        end
-
-        # Validates that a collection attribute is an array
-        #
-        # @param package [Lutaml::Uml::Package] Package to check
-        # @param attribute [Symbol] Attribute name
-        # @param path [String] Package path for error reporting
-        # @return [void]
-        def validate_collection(package, attribute, path) # rubocop:disable Metrics/MethodLength
-          value = package.public_send(attribute)
-          unless value.nil? || value.is_a?(Array)
-            result.add_error(
-              category: :invalid_structure,
-              entity_type: :package,
-              entity_id: package.xmi_id || "unknown",
-              entity_name: package.name,
-              field: attribute.to_s,
-              message: "Package '#{path}' has invalid #{attribute} " \
-                       "(expected Array, got #{value.class})",
-            )
-          end
-        end
-
-        # Validates no duplicate names within same parent
-        #
-        # @return [void]
-        def validate_no_duplicate_names # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return unless document
-
-          # Check top-level entities
-          check_duplicate_names_in_collection(
-            document.classes || [],
-            :class,
-            "top-level",
-          )
-          check_duplicate_names_in_collection(
-            document.enums || [],
-            :enum,
-            "top-level",
-          )
-          check_duplicate_names_in_collection(
-            document.data_types || [],
-            :data_type,
-            "top-level",
-          )
-          check_duplicate_names_in_collection(
-            document.packages || [],
-            :package,
-            "top-level",
-          )
-
-          # Recursively check packages
-          (document.packages || []).each do |package|
-            validate_package_duplicates(package, "")
-          end
-        end
-
-        # Validates no duplicate names within a package recursively
-        #
-        # @param package [Lutaml::Uml::Package] Package to validate
-        # @param parent_path [String] Parent path for context
-        # @return [void]
-        def validate_package_duplicates(package, parent_path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          current_path = if parent_path.empty?
-                           package.name
-                         else
-                           "#{parent_path}::#{package.name}"
-                         end
-
-          # Check for duplicates within this package
-          check_duplicate_names_in_collection(
-            package.classes || [],
-            :class,
-            current_path,
-          )
-          check_duplicate_names_in_collection(
-            package.enums || [],
-            :enum,
-            current_path,
-          )
-          check_duplicate_names_in_collection(
-            package.data_types || [],
-            :data_type,
-            current_path,
-          )
-          check_duplicate_names_in_collection(
-            package.packages || [],
-            :package,
-            current_path,
-          )
-
-          # Recursively check child packages
-          (package.packages || []).each do |child|
-            validate_package_duplicates(child, current_path)
-          end
-        end
-
-        # Checks for duplicate names in a collection
-        #
-        # @param collection [Array] Collection to check
-        # @param entity_type [Symbol] Type of entities
-        # @param context_path [String] Context path for error reporting
-        # @return [void]
-        def check_duplicate_names_in_collection( # rubocop:disable Metrics/MethodLength
-          collection, entity_type, context_path
-        )
-          name_counts = Hash.new(0)
-
-          collection.each do |entity|
-            next unless entity.name
-
-            name_counts[entity.name] += 1
-          end
-
-          name_counts.each do |name, count|
-            next if count <= 1
-
-            result.add_warning(
-              category: :duplicate_name,
-              entity_type: entity_type,
-              entity_id: "unknown",
-              entity_name: name,
-              message: "Duplicate #{entity_type} name '#{name}' found " \
-                       "#{count} times in #{context_path}",
-            )
-          end
-        end
-
-        # Validates type references in attributes
-        #
-        # @return [void]
-        def validate_type_references # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return unless document
-
-          all_classes = extract_all_classes(document)
-          all_data_types = extract_all_data_types(document)
-          all_enums = extract_all_enums(document)
-
-          # Build a set of all valid type names
-          valid_types = Set.new
-          all_classes.each { |cls| valid_types << cls.name if cls.name }
-          all_data_types.each { |dt| valid_types << dt.name if dt.name }
-          all_enums.each { |enum| valid_types << enum.name if enum.name }
-
-          # Check attribute type references
-          all_classes.each do |cls, path|
-            next unless cls.is_a?(Lutaml::Uml::Class) || cls.is_a?(Lutaml::Uml::DataType)
-
-            (cls.attributes || []).each do |attr|
-              next unless attr.type
-              next if primitive_type?(attr.type)
-              next if valid_types.include?(attr.type)
-
-              result.add_warning(
-                category: :invalid_type_reference,
-                entity_type: :attribute,
-                entity_id: attr.xmi_id || "unknown",
-                entity_name: attr.name,
-                field: "type",
-                reference: attr.type,
-                message: "Attribute '#{attr.name}' in class '#{path}' " \
-                         "references unknown type '#{attr.type}'",
-              )
-            end
-          end
-        end
-
-        # Extracts all classes
-        #
-        # @param doc [Lutaml::Uml::Document] Document to extract from
-        # @return [Array<Array>] Array of [class]
-        def extract_all_classes(doc) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-          # Top-level classes
-          classes = doc.classes || []
-
-          # Classes in packages
-          (doc.packages || []).each do |pkg|
-            cls_with_paths = extract_classes_from_package_with_path(pkg, "")
-            cls_with_paths.each do |cls_with_path|
-              classes << cls_with_path[0]
-            end
-          end
-
-          classes.flatten
-        end
-
-        # Extracts classes from package with path
-        #
-        # @param package [Lutaml::Uml::Package] Package to extract from
-        # @param parent_path [String] Parent path
-        # @return [Array<Array>] Array of [class, path] pairs
-        def extract_classes_from_package_with_path(package, parent_path) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          classes = []
-          current_path = if parent_path.empty?
-                           package.name
-                         else
-                           "#{parent_path}::#{package.name}"
-                         end
-
-          (package.classes || []).each do |cls|
-            full_path = "#{current_path}::#{cls.name || 'Unnamed'}"
-            classes << [cls, full_path]
-          end
-
-          (package.packages || []).each do |child|
-            classes.concat(
-              extract_classes_from_package_with_path(child, current_path),
-            )
-          end
-
-          classes
-        end
-
-        # Extracts all data types
-        #
-        # @param doc [Lutaml::Uml::Document] Document to extract from
-        # @return [Array<Array>] Array of [data_type]
-        def extract_all_data_types(doc)
-          data_types = doc.data_types || []
-
-          (doc.packages || []).each do |pkg|
-            dts_with_paths = extract_data_types_from_package_with_path(pkg, "")
-            dts_with_paths.each do |dt_with_path|
-              data_types << dt_with_path[0]
-            end
-          end
-
-          data_types.flatten
-        end
-
-        # Extracts data types from package with path
-        #
-        # @param package [Lutaml::Uml::Package] Package to extract from
-        # @param parent_path [String] Parent path
-        # @return [Array<Array>] Array of [data_type, path] pairs
-        def extract_data_types_from_package_with_path(package, parent_path) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          data_types = []
-          current_path = if parent_path.empty?
-                           package.name
-                         else
-                           "#{parent_path}::#{package.name}"
-                         end
-
-          (package.data_types || []).each do |dt|
-            full_path = "#{current_path}::#{dt.name || 'Unnamed'}"
-            data_types << [dt, full_path]
-          end
-
-          (package.packages || []).each do |child|
-            data_types.concat(
-              extract_data_types_from_package_with_path(child, current_path),
-            )
-          end
-
-          data_types
-        end
-
-        # Extracts all enums with their paths
-        #
-        # @param doc [Lutaml::Uml::Document] Document to extract from
-        # @return [Array<Array>] Array of [enum, path] pairs
-        def extract_all_enums(doc)
-          enums = doc.enums || []
-
-          (doc.packages || []).each do |pkg|
-            enums_with_paths = extract_enums_from_package_with_path(pkg, "")
-            enums_with_paths.each do |enum_with_path|
-              enums << enum_with_path[0]
-            end
-          end
-
-          enums.flatten
-        end
-
-        # Extracts enums from package with path
-        #
-        # @param package [Lutaml::Uml::Package] Package to extract from
-        # @param parent_path [String] Parent path
-        # @return [Array<Array>] Array of [enum, path] pairs
-        def extract_enums_from_package_with_path(package, parent_path) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          enums = []
-          current_path = if parent_path.empty?
-                           package.name
-                         else
-                           "#{parent_path}::#{package.name}"
-                         end
-
-          (package.enums || []).each do |enum|
-            full_path = "#{current_path}::#{enum.name || 'Unnamed'}"
-            enums << [enum, full_path]
-          end
-
-          (package.packages || []).each do |child|
-            enums.concat(
-              extract_enums_from_package_with_path(child, current_path),
-            )
-          end
-
-          enums
-        end
-
-        # Checks if a type is a primitive type
-        #
-        # @param type [String] Type name
-        # @return [Boolean]
-        def primitive_type?(type)
-          return false unless type
-
-          primitive_types = %w[
-            String Integer Float Boolean Date Time DateTime
-            string integer float boolean date time datetime
-            int long short byte double char
-            void
-          ]
-
-          primitive_types.include?(type)
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/value.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Value < Lutaml::Model::Serializable
-      attribute :definition, :string
-      attribute :name, :string
-      attribute :id, :string
-      attribute :type, :string
-
-      yaml do
-        map "name", to: :name
-        map "id", to: :id
-        map "type", to: :type
-
-        map "definition", to: :definition, with: {
-          to: :definition_to_yaml, from: :definition_from_yaml
-        }
-      end
-
-      def definition_to_yaml(model, doc)
-        doc["definition"] = model.definition if model.definition
-      end
-
-      def definition_from_yaml(model, value)
-        model.definition = value.to_s
-          .gsub(/\\}/, "}")
-          .gsub(/\\{/, "{")
-          .split("\n")
-          .map(&:strip)
-          .join("\n")
-      end
-    end
-  end
-end

data/lib/lutaml/uml/vertex.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Vertex < TopElement
-    end
-  end
-end

data/lib/lutaml/uml.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Lutaml
-  module Uml
-    class Error < StandardError; end
-
-    # Base modules and mixins
-    autoload :HasAttributes, "lutaml/uml/has_attributes"
-    autoload :HasMembers, "lutaml/uml/has_members"
-    autoload :ModelHelpers, "lutaml/uml/model_helpers"
-    autoload :Namespace, "lutaml/uml/namespace"
-    autoload :PackagePath, "lutaml/uml/package_path"
-    autoload :QualifiedName, "lutaml/uml/qualified_name"
-
-    # Value types
-    autoload :Cardinality, "lutaml/uml/cardinality"
-    autoload :Fidelity, "lutaml/uml/fidelity"
-    autoload :Value, "lutaml/uml/value"
-    autoload :Fontname, "lutaml/uml/fontname"
-    autoload :TaggedValue, "lutaml/uml/tagged_value"
-
-    # Core elements
-    autoload :TopElement, "lutaml/uml/top_element"
-    autoload :TopElementAttribute, "lutaml/uml/top_element_attribute"
-    autoload :GeneralAttribute, "lutaml/uml/general_attribute"
-
-    # Relationships
-    autoload :AssociationGeneralization, "lutaml/uml/association_generalization"
-    autoload :Generalization, "lutaml/uml/generalization"
-    autoload :Association, "lutaml/uml/association"
-    autoload :Dependency, "lutaml/uml/dependency"
-    autoload :Abstraction, "lutaml/uml/abstraction"
-    autoload :Realization, "lutaml/uml/realization"
-
-    # Classifiers
-    autoload :Classifier, "lutaml/uml/classifier"
-    autoload :Class, "lutaml/uml/class"
-    autoload :DataType, "lutaml/uml/data_type"
-    autoload :Enum, "lutaml/uml/enum"
-    autoload :PrimitiveType, "lutaml/uml/primitive_type"
-    autoload :Actor, "lutaml/uml/actor"
-
-    # Behavioral elements
-    autoload :Action, "lutaml/uml/action"
-    autoload :Behavior, "lutaml/uml/behavior"
-    autoload :Activity, "lutaml/uml/activity"
-    autoload :OpaqueBehavior, "lutaml/uml/opaque_behavior"
-
-    # State machine elements
-    autoload :Vertex, "lutaml/uml/vertex"
-    autoload :State, "lutaml/uml/state"
-    autoload :FinalState, "lutaml/uml/final_state"
-    autoload :Pseudostate, "lutaml/uml/pseudostate"
-    autoload :Region, "lutaml/uml/region"
-    autoload :StateMachine, "lutaml/uml/state_machine"
-    autoload :Transition, "lutaml/uml/transition"
-    autoload :Event, "lutaml/uml/event"
-    autoload :Trigger, "lutaml/uml/trigger"
-
-    # Structural elements
-    autoload :Property, "lutaml/uml/property"
-    autoload :Port, "lutaml/uml/port"
-    autoload :Operation, "lutaml/uml/operation"
-    autoload :OperationParameter, "lutaml/uml/operation_parameter"
-    autoload :Constraint, "lutaml/uml/constraint"
-
-    # Composite elements
-    autoload :Connector, "lutaml/uml/connector"
-    autoload :ConnectorEnd, "lutaml/uml/connector_end"
-    autoload :Group, "lutaml/uml/group"
-    autoload :Package, "lutaml/uml/package"
-    autoload :Model, "lutaml/uml/model"
-
-    # Documentation
-    autoload :Comment, "lutaml/uml/comment"
-    autoload :Diagram, "lutaml/uml/diagram"
-    autoload :DiagramObject, "lutaml/uml/diagram_object"
-    autoload :DiagramLink, "lutaml/uml/diagram_link"
-    autoload :Instance, "lutaml/uml/instance"
-    autoload :Document, "lutaml/uml/document"
-
-    # Node (DSL AST nodes)
-    module Node
-      autoload :Base, "lutaml/uml/node/base"
-      autoload :HasName, "lutaml/uml/node/has_name"
-      autoload :HasType, "lutaml/uml/node/has_type"
-      autoload :Attribute, "lutaml/uml/node/attribute"
-      autoload :ClassNode, "lutaml/uml/node/class_node"
-      autoload :ClassRelationship, "lutaml/uml/node/class_relationship"
-      autoload :Document, "lutaml/uml/node/document"
-      autoload :MethodArgument, "lutaml/uml/node/method_argument"
-      autoload :Operation, "lutaml/uml/node/operation"
-      autoload :Relationship, "lutaml/uml/node/relationship"
-    end
-
-    # Parsers
-    module Parsers
-      autoload :Dsl, "lutaml/uml/parsers/dsl"
-      autoload :DslPreprocessor, "lutaml/uml/parsers/dsl_preprocessor"
-      autoload :DslTransform, "lutaml/uml/parsers/dsl_transform"
-      autoload :Yaml, "lutaml/uml/parsers/yaml"
-      autoload :Attribute, "lutaml/uml/parsers/attribute"
-    end
-
-    # Validation
-    module Validation
-      autoload :DocumentStructureValidator,
-               "lutaml/uml/validation/document_structure_validator"
-    end
-  end
-end

data/lib/lutaml/uml_repository/class_lookup_index.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    # O(1) lookup index for UML classes by various identifiers.
-    #
-    # Replaces O(n) linear scans that were repeated across multiple
-    # transformer and serializer classes.
-    #
-    # @example
-    #   index = ClassLookupIndex.new(repository.classes_index)
-    #   index.by_xmi_id("EAID_123...")
-    #   index.by_object_id(42)
-    class ClassLookupIndex
-      def initialize(classes)
-        @by_xmi_id = {}
-        @by_object_id = {}
-
-        classes.each do |klass|
-          @by_xmi_id[klass.xmi_id] = klass if klass.xmi_id
-          if klass.class.attributes.key?(:ea_object_id) && klass.ea_object_id
-            @by_object_id[klass.ea_object_id] = klass
-          end
-        end
-      end
-
-      # @param xmi_id [String]
-      # @return [Lutaml::Uml::Class, nil]
-      def by_xmi_id(xmi_id)
-        @by_xmi_id[xmi_id]
-      end
-
-      # @param object_id [String, Integer]
-      # @return [Lutaml::Uml::Class, nil]
-      def by_object_id(object_id)
-        @by_object_id[object_id]
-      end
-    end
-  end
-end