lutaml 0.9.43 → 0.10.0

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

@@ -0,0 +1,287 @@
+# 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.respond_to?(:name) && 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.respond_to?(:parameters)
+
+          param_types = (operation.parameters || []).map do |param|
+            param.respond_to?(:type) ? 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.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "qea/infrastructure/database_connection"
+require_relative "qea/infrastructure/schema_reader"
+require_relative "qea/infrastructure/table_reader"
+require_relative "qea/services/configuration"
+require_relative "qea/services/database_loader"
+require_relative "qea/database"
+require_relative "qea/factory/ea_to_uml_factory"
+require_relative "qea/validation/validation_message"
+require_relative "qea/validation/validation_result"
+require_relative "qea/validation/base_validator"
+require_relative "qea/validation/validator_registry"
+require_relative "qea/validation/validation_engine"
+require_relative "qea/validation/formatters/json_formatter"
+require_relative "qea/validation/formatters/text_formatter"
+
+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/sysml/allocate.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Allocate < Lutaml::Uml::Abstraction

data/lib/lutaml/sysml/allocated.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Allocated < Lutaml::Uml::TopElement

data/lib/lutaml/sysml/binding_connector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class BindingConnector < Lutaml::Uml::Connector

data/lib/lutaml/sysml/block.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Block < Lutaml::Uml::Class

data/lib/lutaml/sysml/constraint_block.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class ConstraintBlock < Block

data/lib/lutaml/sysml/copy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Copy < Trace

data/lib/lutaml/sysml/derive_requirement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class DeriveRequirement < Lutaml::Uml::TopElement

data/lib/lutaml/sysml/nested_connector_end.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class NestedConnectorEnd < Lutaml::Uml::ConnectorEnd

data/lib/lutaml/sysml/refine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Refine < Lutaml::Uml::TopElement

data/lib/lutaml/sysml/requirement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Requirement < Lutaml::Uml::Class

data/lib/lutaml/sysml/requirement_related.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class RequirementRelated < Lutaml::Uml::TopElement

data/lib/lutaml/sysml/satisfy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Satisfy < Trace

data/lib/lutaml/sysml/test_case.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class TestCase < Lutaml::Uml::TopElement

data/lib/lutaml/sysml/trace.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Trace < Lutaml::Uml::TopElement

data/lib/lutaml/sysml/verify.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class Verify < Trace

data/lib/lutaml/sysml/xmi_file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Lutaml
   module Sysml
     class XmiFile

data/lib/lutaml/sysml.rb

@@ -1,4 +1,6 @@
-require "lutaml/uml"
+# frozen_string_literal: true
+
+require_relative "uml"
 require "nokogiri"
 
 module Lutaml

data/lib/lutaml/uml/association.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "top_element"
+require_relative "cardinality"
+require_relative "action"
+
 module Lutaml
   module Uml
     class Association < TopElement