lutaml 0.10.19 → 0.11.2

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

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Verification
-      # Matches corresponding elements between XMI and QEA documents
-      # by qualified name/path
-      class StructureMatcher
-        # Match packages between documents
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
-        def match_packages(xmi_doc, qea_doc)
-          xmi_packages = build_package_index(xmi_doc.packages)
-          qea_packages = build_package_index(qea_doc.packages)
-
-          match_elements(xmi_packages, qea_packages)
-        end
-
-        # Match classes between documents
-        #
-        # @param xmi_doc [Lutaml::Uml::Document] XMI document
-        # @param qea_doc [Lutaml::Uml::Document] QEA document
-        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
-        def match_classes(xmi_doc, qea_doc)
-          xmi_classes = build_class_index(xmi_doc)
-          qea_classes = build_class_index(qea_doc)
-
-          match_elements(xmi_classes, qea_classes)
-        end
-
-        # Match attributes between classes
-        #
-        # @param xmi_class [Lutaml::Uml::Class] XMI class
-        # @param qea_class [Lutaml::Uml::Class] QEA class
-        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
-        def match_attributes(xmi_class, qea_class)
-          xmi_attrs = index_by_name(xmi_class.attributes || [])
-          qea_attrs = index_by_name(qea_class.attributes || [])
-
-          match_elements(xmi_attrs, qea_attrs)
-        end
-
-        # Match operations between classes
-        #
-        # @param xmi_class [Lutaml::Uml::Class] XMI class
-        # @param qea_class [Lutaml::Uml::Class] QEA class
-        # @return [Hash] Hash with :matches, :xmi_only, :qea_only
-        def match_operations(xmi_class, qea_class)
-          xmi_ops = index_by_signature(xmi_class.operations || [])
-          qea_ops = index_by_signature(qea_class.operations || [])
-
-          match_elements(xmi_ops, qea_ops)
-        end
-
-        # Build qualified name index for document
-        #
-        # @param document [Lutaml::Uml::Document] The document
-        # @return [Hash] Hash mapping qualified names to elements
-        def build_qualified_names(document)
-          {
-            packages: build_package_index(document.packages),
-            classes: build_class_index(document),
-            enums: build_enum_index(document),
-            data_types: build_data_type_index(document),
-          }
-        end
-
-        private
-
-        # Build package index with qualified paths
-        def build_package_index(packages, parent_path = "") # rubocop:disable Metrics/MethodLength
-          index = {}
-          return index unless packages
-
-          packages.each do |package|
-            next unless package.name
-
-            qualified_path = build_path(parent_path, package.name)
-            index[qualified_path] = package
-
-            # Recursively index nested packages
-            nested = build_package_index(package.packages, qualified_path)
-            index.merge!(nested)
-          end
-
-          index
-        end
-
-        # Build class index from document and packages
-        def build_class_index(document) # rubocop:disable Metrics/MethodLength
-          index = {}
-
-          # Index top-level classes
-          document.classes&.each do |klass|
-            next unless klass.name
-
-            index[klass.name] = klass
-          end
-
-          # Index classes in packages
-          if document.packages
-            index_classes_in_packages(document.packages, "",
-                                      index)
-          end
-
-          index
-        end
-
-        # Recursively index classes in packages
-        def index_classes_in_packages(packages, parent_path, index) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-          return unless packages
-
-          packages.each do |package|
-            next unless package.name
-
-            package_path = build_path(parent_path, package.name)
-
-            package.classes&.each do |klass|
-              next unless klass.name
-
-              qualified_name = "#{package_path}::#{klass.name}"
-              index[qualified_name] = klass
-            end
-
-            # Recurse into nested packages
-            index_classes_in_packages(package.packages, package_path, index)
-          end
-        end
-
-        # Build enum index from document and packages
-        def build_enum_index(document) # rubocop:disable Metrics/MethodLength
-          index = {}
-
-          # Index top-level enums
-          document.enums&.each do |enum|
-            next unless enum.name
-
-            index[enum.name] = enum
-          end
-
-          # Index enums in packages
-          if document.packages
-            index_enums_in_packages(document.packages, "",
-                                    index)
-          end
-
-          index
-        end
-
-        # Recursively index enums in packages
-        def index_enums_in_packages(packages, parent_path, index) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-          return unless packages
-
-          packages.each do |package|
-            next unless package.name
-
-            package_path = build_path(parent_path, package.name)
-
-            package.enums&.each do |enum|
-              next unless enum.name
-
-              qualified_name = "#{package_path}::#{enum.name}"
-              index[qualified_name] = enum
-            end
-
-            # Recurse into nested packages
-            index_enums_in_packages(package.packages, package_path, index)
-          end
-        end
-
-        # Build data type index from document and packages
-        def build_data_type_index(document) # rubocop:disable Metrics/MethodLength
-          index = {}
-
-          # Index top-level data types
-          document.data_types&.each do |dt|
-            next unless dt.name
-
-            index[dt.name] = dt
-          end
-
-          # Index data types in packages
-          if document.packages
-            index_data_types_in_packages(document.packages, "",
-                                         index)
-          end
-
-          index
-        end
-
-        # Recursively index data types in packages
-        def index_data_types_in_packages(packages, parent_path, index) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-          return unless packages
-
-          packages.each do |package|
-            next unless package.name
-
-            package_path = build_path(parent_path, package.name)
-
-            package.data_types&.each do |dt|
-              next unless dt.name
-
-              qualified_name = "#{package_path}::#{dt.name}"
-              index[qualified_name] = dt
-            end
-
-            # Recurse into nested packages
-            index_data_types_in_packages(package.packages, package_path, index)
-          end
-        end
-
-        # Build qualified path from parent and name
-        def build_path(parent_path, name)
-          return name if parent_path.empty?
-
-          "#{parent_path}::#{name}"
-        end
-
-        # Index collection by name
-        def index_by_name(collection)
-          index = {}
-          collection.each do |element|
-            next unless element.name
-
-            index[element.name] = element
-          end
-          index
-        end
-
-        # Index operations by signature (name + parameter types)
-        def index_by_signature(operations)
-          index = {}
-          operations.each do |operation|
-            next unless operation.name
-
-            signature = build_operation_signature(operation)
-            index[signature] = operation
-          end
-          index
-        end
-
-        # Build operation signature for matching
-        def build_operation_signature(operation)
-          return operation.name unless operation.owned_parameter
-
-          param_types = operation.owned_parameter.map do |param|
-            param.type || "unknown"
-          end.join(",")
-
-          "#{operation.name}(#{param_types})"
-        end
-
-        # Match elements between two indexes
-        def match_elements(xmi_index, qea_index) # rubocop:disable Metrics/MethodLength
-          matches = {}
-          xmi_only = []
-          qea_only = []
-
-          # Find matches and XMI-only elements
-          xmi_index.each do |key, xmi_element|
-            if qea_index.key?(key)
-              matches[key] = {
-                xmi: xmi_element,
-                qea: qea_index[key],
-              }
-            else
-              xmi_only << key
-            end
-          end
-
-          # Find QEA-only elements
-          qea_index.each_key do |key|
-            qea_only << key unless xmi_index.key?(key)
-          end
-
-          {
-            matches: matches,
-            xmi_only: xmi_only.sort,
-            qea_only: qea_only.sort,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/verification.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Verification
-      autoload :DocumentNormalizer,
-               "lutaml/qea/verification/document_normalizer"
-      autoload :StructureMatcher, "lutaml/qea/verification/structure_matcher"
-      autoload :ElementComparator, "lutaml/qea/verification/element_comparator"
-      autoload :ComparisonResult, "lutaml/qea/verification/comparison_result"
-      autoload :DocumentVerifier, "lutaml/qea/verification/document_verifier"
-    end
-  end
-end

data/lib/lutaml/qea.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    autoload :Infrastructure, "lutaml/qea/infrastructure"
-    autoload :Services, "lutaml/qea/services"
-    autoload :Models, "lutaml/qea/models"
-    autoload :Factory, "lutaml/qea/factory"
-    autoload :Validation, "lutaml/qea/validation"
-    autoload :Verification, "lutaml/qea/verification"
-    autoload :Database, "lutaml/qea/database"
-    autoload :Repositories, "lutaml/qea/repositories"
-    autoload :Parser, "lutaml/qea/parser"
-    autoload :Benchmark, "lutaml/qea/benchmark"
-    autoload :FileDetector, "lutaml/qea/file_detector"
-  end
-end
-
-module Lutaml
-  # QEA module provides direct SQLite database parsing for Enterprise Architect
-  # .qea files, bypassing XMI for better performance and access to EA-specific
-  # metadata.
-  #
-  # This is the main public API for working with QEA files.
-  #
-  # @example Connect and read schema
-  #   conn = Lutaml::Qea::Infrastructure::DatabaseConnection.new("model.qea")
-  #   conn.with_connection do |db|
-  #     reader = Lutaml::Qea::Infrastructure::SchemaReader.new(db)
-  #     puts reader.tables
-  #   end
-  #
-  # @example Load configuration
-  #   config = Lutaml::Qea::Services::Configuration.load
-  #   puts config.enabled_tables.map(&:table_name)
-  module Qea
-    # QEA Parser version
-    VERSION = "0.1.0"
-
-    class << self
-      # Get the current configuration
-      #
-      # @return [Services::Configuration] The loaded configuration
-      def configuration
-        @configuration ||= Services::Configuration.load
-      end
-
-      # Set a custom configuration
-      #
-      # @param config [Services::Configuration] The configuration to use
-      def configuration=(config)
-        @configuration = config
-      end
-
-      # Reload configuration from file
-      #
-      # @param config_path [String, nil] Optional custom config path
-      # @return [Services::Configuration] The reloaded configuration
-      def reload_configuration(config_path = nil)
-        @configuration = Services::Configuration.load(config_path)
-      end
-
-      # Connect to a QEA file
-      #
-      # @param file_path [String] Path to the .qea file
-      # @return [Infrastructure::DatabaseConnection] The connection object
-      #
-      # @example
-      #   conn = Qea.connect("model.qea")
-      #   conn.with_connection do |db|
-      #     # Use db
-      #   end
-      def connect(file_path)
-        Infrastructure::DatabaseConnection.new(file_path)
-      end
-
-      # Open a QEA file and yield the connection
-      #
-      # @param file_path [String] Path to the .qea file
-      # @yield [Infrastructure::DatabaseConnection] The connection object
-      # @return [Object] The result of the block
-      #
-      # @example
-      #   Qea.open("model.qea") do |conn|
-      #     conn.with_connection do |db|
-      #       reader = Qea::Infrastructure::SchemaReader.new(db)
-      #       puts reader.tables
-      #     end
-      #   end
-      def open(file_path)
-        connection = connect(file_path)
-        yield connection
-      ensure
-        connection&.close if connection&.connected?
-      end
-
-      # Get schema information from a QEA file
-      #
-      # @param file_path [String] Path to the .qea file
-      # @return [Hash] Schema information including tables and row counts
-      #
-      # @example
-      #   info = Qea.schema_info("model.qea")
-      #   puts info[:tables]
-      #   puts info[:statistics]
-      def schema_info(file_path)
-        connection = connect(file_path)
-        connection.with_connection do |db|
-          reader = Infrastructure::SchemaReader.new(db)
-          {
-            tables: reader.tables,
-            statistics: reader.statistics,
-          }
-        end
-      ensure
-        connection&.close if connection&.connected?
-      end
-
-      # Load complete database with all tables and models
-      #
-      # @param qea_path [String] Path to the .qea file
-      # @param config [Services::Configuration, nil]
-      # Optional custom configuration
-      # @return [Database] Loaded database with all collections
-      #
-      # @example Load database
-      #   database = Qea.load_database("model.qea")
-      #   puts database.stats
-      #   # => {"objects" => 693, "attributes" => 1910, ...}
-      #
-      # @example With progress callback
-      #   database = Qea.load_database("model.qea") do |table, current, total|
-      #     puts "Loading #{table}: #{current}/#{total}"
-      #   end
-      def load_database(qea_path, config = nil, &progress_callback)
-        loader = Services::DatabaseLoader.new(qea_path, config)
-        loader.on_progress(&progress_callback) if progress_callback
-        loader.load
-      end
-
-      # Get quick database statistics without full loading
-      #
-      # @param qea_path [String] Path to the .qea file
-      # @param config [Services::Configuration, nil]
-      # Optional custom configuration
-      # @return [Hash<String, Integer>] Collection names to record counts
-      #
-      # @example
-      #   info = Qea.database_info("model.qea")
-      #   puts info
-      #   # => {"objects" => 693, "attributes" => 1910, ...}
-      def database_info(qea_path, config = nil)
-        loader = Services::DatabaseLoader.new(qea_path, config)
-        loader.quick_stats
-      end
-
-      # Parse QEA file to complete UML Document
-      #
-      # @param qea_path [String] Path to the .qea file
-      # @param options [Hash] Transformation options
-      # @option options [Boolean] :include_diagrams Include diagrams
-      # (default: true)
-      # @option options [Boolean] :validate Validate during parsing
-      # (default: false)
-      # @option options [String] :document_name Document name
-      # @option options [Services::Configuration] :config Custom configuration
-      # @return [Lutaml::Uml::Document, Hash] Document, or hash with
-      # :document and :validation_result
-      #
-      # @example Parse QEA file
-      #   document = Lutaml::Qea.parse("model.qea")
-      #   puts "Packages: #{document.packages.size}"
-      #   puts "Classes: #{document.classes.size}"
-      #   puts "Associations: #{document.associations.size}"
-      #
-      # @example Parse with validation
-      #   result = Lutaml::Qea.parse("model.qea", validate: true)
-      #   document = result[:document]
-      #   validation = result[:validation_result]
-      #   puts validation.summary
-      #
-      # @example Use with UmlRepository
-      #   document = Lutaml::Qea.parse("model.qea")
-      #   repo = Lutaml::UmlRepository::Repository.new(document: document)
-      #   results = repo.search("Building")
-      #   puts "Found #{results[:total]} matches"
-      def parse(qea_path, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        # Extract config and validation options
-        config = options.delete(:config)
-        validate = options.delete(:validate)
-
-        # Load database (connection stays open)
-        loader = Services::DatabaseLoader.new(qea_path, config)
-        ea_database = loader.load
-
-        begin
-          # Create and execute factory
-          factory = Factory::EaToUmlFactory.new(ea_database, options)
-          document = factory.create_document
-
-          # Run validation if requested
-          if validate
-            engine = Validation::ValidationEngine.new(
-              document,
-              database: ea_database,
-              **options,
-            )
-            validation_result = engine.validate
-
-            {
-              document: document,
-              validation_result: validation_result,
-            }
-          else
-            document
-          end
-        ensure
-          # Close the connection when done (unless validation needs it)
-          if !validate &&
-              ea_database.connection && !ea_database.connection.closed?
-            ea_database.connection&.close
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml/abstraction.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Abstraction < Dependency
-      skip_reference_registration
-    end
-  end
-end

data/lib/lutaml/uml/action.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Action < Lutaml::Model::Serializable
-      skip_reference_registration
-
-      attribute :verb, :string
-      attribute :direction, :string
-
-      yaml do
-        map "verb", to: :verb
-        map "direction", to: :direction
-      end
-    end
-  end
-end

data/lib/lutaml/uml/activity.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Activity < Behavior
-      skip_reference_registration
-    end
-  end
-end

data/lib/lutaml/uml/actor.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Actor < Classifier
-      skip_reference_registration
-    end
-  end
-end

data/lib/lutaml/uml/association.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Association < TopElement
-      skip_reference_registration
-
-      attribute :owner_end, :string
-      attribute :owner_end_attribute_name, :string
-      attribute :owner_end_cardinality, Cardinality
-      attribute :owner_end_type, :string
-      attribute :owner_end_xmi_id, :string
-      attribute :member_end, :string
-      attribute :member_end_attribute_name, :string
-      attribute :member_end_xmi_id, :string
-      attribute :member_end_cardinality, Cardinality
-      attribute :member_end_type, :string
-      attribute :static, :string
-      attribute :action, Action
-
-      yaml do
-        map "owner_end", to: :owner_end
-        map "owner_end_attribute_name", to: :owner_end_attribute_name
-        map "owner_end_cardinality", to: :owner_end_cardinality
-        map "owner_end_type", to: :owner_end_type
-        map "owner_end_xmi_id", to: :owner_end_xmi_id
-        map "member_end", to: :member_end
-        map "member_end_attribute_name", to: :member_end_attribute_name
-        map "member_end_xmi_id", to: :member_end_xmi_id
-        map "member_end_cardinality", to: :member_end_cardinality
-        map "member_end_type", to: :member_end_type
-        map "static", to: :static
-        map "action", to: :action
-      end
-    end
-  end
-end

data/lib/lutaml/uml/association_generalization.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class AssociationGeneralization < Lutaml::Model::Serializable
-      skip_reference_registration
-
-      attribute :id, :string
-      attribute :type, :string
-      attribute :general, :string
-      attribute :parent_object_id, :string
-
-      yaml do
-        map "id", to: :id
-        map "type", to: :type
-        map "general", to: :general
-      end
-    end
-  end
-end

data/lib/lutaml/uml/behavior.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-##
-## Behaviour metamodel
-##
-module Lutaml
-  module Uml
-    class Behavior < Class
-      skip_reference_registration
-    end
-  end
-end

data/lib/lutaml/uml/cardinality.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Uml
-    class Cardinality < Lutaml::Model::Serializable
-      skip_reference_registration
-
-      attribute :min, :string
-      attribute :max, :string
-    end
-  end
-end