lutaml 0.10.19 → 0.11.2

data/lib/lutaml/model_transformations.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  # Model Transformations module provides a unified, extensible system for
-  # transforming various UML model formats (XMI, QEA, etc.) into a common
-  # UML document representation.
-  #
-  # This module follows SOLID principles and implements:
-  # - Single Responsibility: Each component has one clear purpose
-  # - Open/Closed: Easy to extend with new formats without modifying existing
-  # code
-  # - Liskov Substitution: All parsers implement the same interface
-  # - Interface Segregation: Clients depend only on methods they use
-  # - Dependency Inversion: Depends on abstractions, not concrete
-  # implementations
-  #
-  # @example Parse any supported format
-  #   engine = Lutaml::ModelTransformations::TransformationEngine.new
-  #   document = engine.parse("model.xmi")
-  #   document = engine.parse("model.qea")
-  #
-  # @example Register custom parser
-  #   engine.register_parser(".custom", MyCustomParser)
-  #   document = engine.parse("model.custom")
-  #
-  # @example Use custom configuration
-  #   config = Lutaml::ModelTransformations::Configuration.load("my_config.yml")
-  #   engine = Lutaml::ModelTransformations::TransformationEngine.new(config)
-  module ModelTransformations
-    # Core components
-    autoload :Configuration, "lutaml/model_transformations/configuration"
-    autoload :FormatRegistry, "lutaml/model_transformations/format_registry"
-    autoload :TransformationEngine,
-             "lutaml/model_transformations/transformation_engine"
-
-    # Parsers
-    module Parsers
-      autoload :BaseParser, "lutaml/model_transformations/parsers/base_parser"
-      autoload :XmiParser, "lutaml/model_transformations/parsers/xmi_parser"
-      autoload :QeaParser, "lutaml/model_transformations/parsers/qea_parser"
-    end
-    class << self
-      # Get the default transformation engine
-      #
-      # @return [TransformationEngine] The default engine instance
-      def engine
-        @engine ||= TransformationEngine.new
-      end
-
-      # Set a custom transformation engine
-      #
-      # @param engine [TransformationEngine] The engine to use
-      def engine=(engine)
-        @engine = engine
-      end
-
-      # Parse a model file using the default engine
-      #
-      # @param file_path [String] Path to the model file
-      # @param options [Hash] Parsing options
-      # @return [Lutaml::Uml::Document] The parsed UML document
-      def parse(file_path, options = {})
-        engine.parse(file_path, options)
-      end
-
-      # Auto-detect file format and return appropriate parser
-      #
-      # @param file_path [String] Path to the model file
-      # @return [Class] The parser class for the file format
-      def detect_parser(file_path)
-        engine.detect_parser(file_path)
-      end
-
-      # Get list of supported file extensions
-      #
-      # @return [Array<String>] List of supported extensions
-      def supported_extensions
-        engine.supported_extensions
-      end
-
-      # Check if a file is supported
-      #
-      # @param file_path [String] Path to the model file
-      def supports_file?(file_path)
-        engine.supports_file?(file_path)
-      end
-
-      # Get transformation statistics
-      #
-      # @return [Hash] Statistics data
-      def statistics
-        engine.statistics
-      end
-
-      # Reset transformation statistics
-      def reset_statistics
-        engine.clear_history
-      end
-
-      # Validate setup of the transformation engine
-      def validate_setup
-        engine.validate_setup
-      end
-
-      # Register a custom parser for a file extension
-      #
-      # @param extension [String] File extension (e.g., ".custom")
-      # @param parser_class [Class] Parser class implementing BaseParser
-      # interface
-      def register_parser(extension, parser_class)
-        engine.register_parser(extension, parser_class)
-      end
-
-      # Load configuration from file
-      #
-      # @param config_path [String] Path to configuration file
-      # @return [Configuration] The loaded configuration
-      def load_configuration(config_path)
-        engine.configuration = Configuration.load(config_path)
-      end
-
-      # Get current configuration
-      #
-      # @return [Configuration] The current configuration
-      def configuration
-        engine.configuration
-      end
-
-      # Set configuration
-      #
-      # @param config [Configuration] The configuration to use
-      def configuration=(config)
-        engine.configuration = config
-      end
-
-      # Configure using a block
-      # @yieldparam config [Configuration] The configuration to modify
-      def configure
-        yield(configuration) if block_given?
-      end
-    end
-  end
-end

data/lib/lutaml/qea/benchmark.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark"
-
-module Lutaml
-  module Qea
-    # Performance benchmarking utilities for comparing QEA vs XMI parsing
-    class Benchmark
-      class << self
-        # Compare QEA and XMI parsing performance
-        #
-        # @param qea_path [String] Path to QEA file
-        # @param xmi_path [String] Path to XMI file
-        # @return [Hash] Benchmark results
-        #
-        # @example
-        #   results = Lutaml::Qea::Benchmark.compare(
-        #     "model.qea",
-        #     "model.xmi"
-        #   )
-        #   puts "QEA: #{results[:qea][:time]}s"
-        #   puts "XMI: #{results[:xmi][:time]}s"
-        #   puts "Speedup: #{results[:speedup]}x"
-        def compare(qea_path, xmi_path) # rubocop:disable Metrics/MethodLength
-          qea_result = measure_qea(qea_path)
-          xmi_result = measure_xmi(xmi_path)
-
-          speedup = if qea_result[:time].positive?
-                      (xmi_result[:time] / qea_result[:time]).round(2)
-                    else
-                      0
-                    end
-
-          {
-            qea: qea_result,
-            xmi: xmi_result,
-            speedup: speedup,
-            improvement_percent: ((speedup - 1) * 100).round(1),
-          }
-        end
-
-        # Measure QEA parsing performance
-        #
-        # @param path [String] Path to QEA file
-        # @return [Hash] Performance metrics
-        #
-        # @example
-        #   result = Lutaml::Qea::Benchmark.measure_qea("model.qea")
-        #   puts "Time: #{result[:time]}s"
-        #   puts "Packages: #{result[:stats][:packages]}"
-        def measure_qea(path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          unless File.exist?(path)
-            return { error: "File not found: #{path}" }
-          end
-
-          result = {
-            file: path,
-            file_size_mb: (File.size(path) / 1024.0 / 1024.0).round(2),
-            format: "QEA",
-          }
-
-          # Measure parsing time
-          document = nil
-          time = ::Benchmark.realtime do
-            document = Lutaml::Qea.parse(path)
-          end
-
-          result[:time] = time.round(3)
-          result[:stats] = {
-            packages: document.packages&.size || 0,
-            classes: document.classes&.size || 0,
-            associations: document.associations&.size || 0,
-            diagrams: document.diagrams&.size || 0,
-          }
-
-          # Calculate throughput
-          if result[:file_size_mb].positive? && time.positive?
-            result[:throughput_mb_per_sec] =
-              (result[:file_size_mb] / time).round(2)
-          end
-
-          result
-        rescue StandardError => e
-          {
-            error: e.message,
-            file: path,
-            format: "QEA",
-          }
-        end
-
-        # Measure XMI parsing performance
-        #
-        # @param path [String] Path to XMI file
-        # @return [Hash] Performance metrics
-        #
-        # @example
-        #   result = Lutaml::Qea::Benchmark.measure_xmi("model.xmi")
-        #   puts "Time: #{result[:time]}s"
-        def measure_xmi(path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          unless File.exist?(path)
-            return { error: "File not found: #{path}" }
-          end
-
-          result = {
-            file: path,
-            file_size_mb: (File.size(path) / 1024.0 / 1024.0).round(2),
-            format: "XMI",
-          }
-
-          # Measure parsing time
-          document = nil
-          time = ::Benchmark.realtime do
-            File.open(path) do |file|
-              document = Lutaml::Xmi::Parsers::Xml.parse(file)
-            end
-          end
-
-          result[:time] = time.round(3)
-          result[:stats] = {
-            packages: document.packages&.size || 0,
-            classes: document.classes&.size || 0,
-            associations: document.associations&.size || 0,
-            diagrams: document.diagrams&.size || 0,
-          }
-
-          # Calculate throughput
-          if result[:file_size_mb].positive? && time.positive?
-            result[:throughput_mb_per_sec] =
-              (result[:file_size_mb] / time).round(2)
-          end
-
-          result
-        rescue StandardError => e
-          {
-            error: e.message,
-            file: path,
-            format: "XMI",
-          }
-        end
-
-        # Format benchmark results for display
-        #
-        # @param results [Hash] Results from compare method
-        # @return [String] Formatted text
-        def format_results(results) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return results[:error] if results[:error]
-
-          output = []
-          output << ("=" * 80)
-          output << "QEA vs XMI Performance Comparison"
-          output << ("=" * 80)
-          output << ""
-
-          if results[:qea][:error]
-            output << "QEA Error: #{results[:qea][:error]}"
-          else
-            output << "QEA File:"
-            output << "  Path:       #{results[:qea][:file]}"
-            output << "  Size:       #{results[:qea][:file_size_mb]} MB"
-            output << "  Parse Time: #{results[:qea][:time]}s"
-            if results[:qea][:throughput_mb_per_sec]
-              output << "  Throughput: " \
-                        "#{results[:qea][:throughput_mb_per_sec]} MB/s"
-            end
-            output << "  Packages:   #{results[:qea][:stats][:packages]}"
-            output << "  Classes:    #{results[:qea][:stats][:classes]}"
-          end
-
-          output << ""
-
-          if results[:xmi][:error]
-            output << "XMI Error: #{results[:xmi][:error]}"
-          else
-            output << "XMI File:"
-            output << "  Path:       #{results[:xmi][:file]}"
-            output << "  Size:       #{results[:xmi][:file_size_mb]} MB"
-            output << "  Parse Time: #{results[:xmi][:time]}s"
-            if results[:xmi][:throughput_mb_per_sec]
-              output << "  Throughput: " \
-                        "#{results[:xmi][:throughput_mb_per_sec]} MB/s"
-            end
-            output << "  Packages:   #{results[:xmi][:stats][:packages]}"
-            output << "  Classes:    #{results[:xmi][:stats][:classes]}"
-          end
-
-          output << ""
-          output << "Performance Improvement:"
-          output << "  QEA is #{results[:speedup]}x faster than XMI"
-          output << "  Improvement: #{results[:improvement_percent]}%"
-          output << ""
-
-          # Add interpretation
-          output << if results[:speedup] >= 10
-                      "  ✓ Significant performance improvement with QEA"
-                    elsif results[:speedup] >= 5
-                      "  ✓ Notable performance improvement with QEA"
-                    elsif results[:speedup] >= 2
-                      "  ✓ Moderate performance improvement with QEA"
-                    else
-                      "  ~ Minimal performance difference"
-                    end
-
-          output << ("=" * 80)
-
-          output.join("\n")
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/database.rb

@@ -1,270 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    # Database container for all loaded EA models
-    #
-    # This class provides a unified container for all EA table collections
-    # loaded from a QEA database. It stores collections by name and provides
-    # accessor methods, statistics, and lookup functionality.
-    #
-    # @example Load and access database
-    #   database = Lutaml::Qea::Services::DatabaseLoader.new("file.qea").load
-    #   puts database.stats
-    #   # => {"objects" => 693, "attributes" => 1910, ...}
-    #
-    #   classes = database.objects.find_by_type("Class")
-    #   obj = database.find_object(123)
-    class Database
-      # @return [Hash<Symbol, Array>] Collections of records by name
-      attr_reader :collections
-
-      # @return [String] Path to the QEA file
-      attr_reader :qea_path
-
-      # @return [SQLite3::Database, nil] Database connection
-      attr_reader :connection
-
-      def initialize(qea_path, connection = nil)
-        @qea_path = qea_path
-        @connection = connection
-        @collections = {}
-        @mutex = Mutex.new
-      end
-
-      # Set database connection
-      #
-      # @param connection [SQLite3::Database] Database connection
-      # @return [void]
-      def connection=(connection)
-        @connection = connection
-      end
-
-      # Add a collection to the database
-      #
-      # @param name [Symbol, String] Collection name (e.g., :objects)
-      # @param records [Array] Array of model instances
-      # @return [void]
-      def add_collection(name, records)
-        @mutex.synchronize do
-          @collections[name.to_sym] = records.freeze
-        end
-      end
-
-      COLLECTION_ACCESSORS = %i[
-        attributes operations operation_params connectors packages
-        diagrams diagram_objects diagram_links object_constraints
-        tagged_values object_properties attribute_tags xrefs
-        stereotypes datatypes constraint_types connector_types
-        diagram_types object_types status_types complexity_types
-        documents scripts
-      ].freeze
-
-      COLLECTION_ACCESSORS.each do |name|
-        define_method(name) do
-          @collections[name] || []
-        end
-      end
-
-      # Get objects collection (special: wrapped in ObjectRepository)
-      #
-      # @return [Repositories::ObjectRepository] Repository for objects
-      def objects
-        return @objects if defined?(@objects)
-
-        @objects = Repositories::ObjectRepository.new(
-          @collections[:objects] || [],
-        )
-      end
-
-      # Get statistics for all collections
-      #
-      # @return [Hash<String, Integer>] Record counts by collection name
-      #
-      # @example
-      #   database.stats
-      #   # => {
-      #   #   "objects" => 693,
-      #   #   "attributes" => 1910,
-      #   #   "connectors" => 908,
-      #   #   ...
-      #   # }
-      def stats
-        @collections.each_with_object({}) do |(name, records), hash|
-          hash[name.to_s] = records.size
-        end
-      end
-
-      # Get total number of records across all collections
-      #
-      # @return [Integer] Total record count
-      def total_records
-        @collections.values.sum(&:size)
-      end
-
-      def find_package(id)
-        ensure_lookup_indexes
-        @packages_by_id[id]
-      end
-
-      def find_attribute(id)
-        ensure_lookup_indexes
-        @attributes_by_id[id]
-      end
-
-      def find_connector(id)
-        ensure_lookup_indexes
-        @connectors_by_id[id]
-      end
-
-      def find_diagram(id)
-        ensure_lookup_indexes
-        @diagrams_by_id[id]
-      end
-
-      def attributes_for_object(id)
-        ensure_lookup_indexes
-        @attributes_by_object_id[id] || []
-      end
-
-      def operations_for_object(id)
-        ensure_lookup_indexes
-        @operations_by_object_id[id] || []
-      end
-
-      def operation_params_for(id)
-        ensure_lookup_indexes
-        @operation_params_by_id[id] || []
-      end
-
-      def child_packages_for(id)
-        ensure_lookup_indexes
-        @packages_by_parent[id] || []
-      end
-
-      def objects_in_package(id)
-        ensure_lookup_indexes
-        @objects_by_package_id[id] || []
-      end
-
-      def diagrams_in_package(id)
-        ensure_lookup_indexes
-        @diagrams_by_package_id[id] || []
-      end
-
-      def diagram_objects_for(id)
-        ensure_lookup_indexes
-        @diagram_objects_by_id[id] || []
-      end
-
-      def diagram_links_for(id)
-        ensure_lookup_indexes
-        @diagram_links_by_id[id] || []
-      end
-
-      # Find an object by ID
-      def find_object(id)
-        objects.find_by_key(:ea_object_id, id)
-      end
-
-      # Find object by ea_guid
-      def find_object_by_guid(ea_guid)
-        ensure_lookup_indexes
-        @objects_by_guid[ea_guid]
-      end
-
-      # Get connectors involving a specific object (start or end)
-      def connectors_for_object(object_id)
-        ensure_lookup_indexes
-        (@connectors_by_start[object_id] || []) +
-          (@connectors_by_end[object_id] || [])
-      end
-
-      # Check if database is empty
-      #
-      # @return [Boolean] true if no collections loaded
-      def empty?
-        @collections.empty? || total_records.zero?
-      end
-
-      # Get collection names
-      #
-      # @return [Array<Symbol>] Array of collection names
-      def collection_names
-        @collections.keys
-      end
-
-      # Freeze all collections to make database immutable
-      #
-      # @return [self]
-      def freeze
-        objects
-        ensure_lookup_indexes
-        @collections.freeze
-        super
-      end
-
-      private
-
-      def ensure_lookup_indexes
-        return if @lookup_indexes_built
-
-        build_lookup_indexes
-        @lookup_indexes_built = true
-      end
-
-      def build_group_index(collection, method, single: false)
-        collection.each_with_object({}) do |item, hash|
-          key = item.public_send(method)
-          next unless key
-
-          single ? (hash[key] = item) : ((hash[key] ||= []) << item)
-        end
-      end
-
-      def build_lookup_indexes
-        build_primary_indexes
-        build_secondary_indexes
-      end
-
-      def build_primary_indexes
-        build_object_indexes
-        build_feature_indexes
-        build_connector_indexes
-        build_diagram_indexes
-      end
-
-      def build_object_indexes
-        @objects_by_guid = build_group_index(objects, :ea_guid, single: true)
-        @objects_by_package_id = build_group_index(objects, :package_id)
-        @packages_by_parent = build_group_index(packages, :parent_id)
-      end
-
-      def build_feature_indexes
-        @attributes_by_object_id = build_group_index(attributes, :ea_object_id)
-        @operations_by_object_id = build_group_index(operations, :ea_object_id)
-        @operation_params_by_id = build_group_index(operation_params,
-                                                    :operationid)
-      end
-
-      def build_connector_indexes
-        @connectors_by_start = build_group_index(connectors, :start_object_id)
-        @connectors_by_end = build_group_index(connectors, :end_object_id)
-      end
-
-      def build_diagram_indexes
-        @diagrams_by_package_id = build_group_index(diagrams, :package_id)
-        @diagram_objects_by_id = build_group_index(diagram_objects, :diagram_id)
-        @diagram_links_by_id = build_group_index(diagram_links, :diagramid)
-      end
-
-      def build_secondary_indexes
-        @packages_by_id = build_group_index(packages, :package_id, single: true)
-        @connectors_by_id = build_group_index(connectors, :connector_id,
-                                              single: true)
-        @diagrams_by_id = build_group_index(diagrams, :diagram_id, single: true)
-        @attributes_by_id = build_group_index(attributes, :id, single: true)
-      end
-    end
-  end
-end