lutaml 0.10.18 → 0.11.2

data/lib/lutaml/qea/repositories.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Repositories
-      autoload :BaseRepository, "lutaml/qea/repositories/base_repository"
-      autoload :ObjectRepository, "lutaml/qea/repositories/object_repository"
-    end
-  end
-end

data/lib/lutaml/qea/services/configuration.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-require "yaml"
-
-module Lutaml
-  module Qea
-    module Services
-      # Configuration service loads and provides configuration from YAML file.
-      #
-      # This service uses lutaml-model for YAML parsing and provides access to
-      # QEA schema configuration including table definitions, type mappings,
-      # and transformation rules.
-      #
-      # @example Load configuration
-      #   config = Configuration.load
-      #   tables = config.enabled_tables
-      #
-      # @example Get table configuration
-      #   table_cfg = config.table_config_for("t_object")
-      class Configuration < Lutaml::Model::Serializable
-        # Column definition model
-        class ColumnDefinition < Lutaml::Model::Serializable
-          attribute :name, :string
-          attribute :type, :string
-          attribute :primary, :boolean, default: -> { false }
-          attribute :nullable, :boolean, default: -> { true }
-          attribute :boolean, :boolean, default: -> { false }
-          attribute :default, :string
-
-          yaml do
-            map "name", to: :name
-            map "type", to: :type
-            map "primary", to: :primary
-            map "nullable", to: :nullable
-            map "boolean", to: :boolean
-            map "default", to: :default
-          end
-        end
-
-        # Table definition model
-        class TableDefinition < Lutaml::Model::Serializable
-          attribute :table_name, :string
-          attribute :enabled, :boolean, default: -> { true }
-          attribute :primary_key, :string
-          attribute :collection_name, :string
-          attribute :description, :string
-          attribute :columns, ColumnDefinition, collection: true
-
-          yaml do
-            map "table_name", to: :table_name
-            map "enabled", to: :enabled
-            map "primary_key", to: :primary_key
-            map "collection_name", to: :collection_name
-            map "description", to: :description
-            map "columns", to: :columns
-          end
-
-          # Get column definition by name
-          #
-          # @param column_name [String] The column name
-          # @return [ColumnDefinition, nil] The column definition or nil
-          def column_for(column_name)
-            columns&.find { |col| col.name == column_name }
-          end
-
-          # Check if a column is boolean type
-          #
-          # @param column_name [String] The column name
-          # @return [Boolean] true if column should be treated as boolean
-          def boolean_column?(column_name)
-            col = column_for(column_name)
-            col&.boolean == true
-          end
-        end
-
-        # Null handling configuration model
-        class NullHandling < Lutaml::Model::Serializable
-          attribute :strategy, :string
-          attribute :empty_string_as_null, :boolean, default: -> { true }
-          attribute :zero_as_null, :boolean, default: -> { false }
-
-          yaml do
-            map "strategy", to: :strategy
-            map "empty_string_as_null", to: :empty_string_as_null
-            map "zero_as_null", to: :zero_as_null
-          end
-        end
-
-        attribute :version, :string
-        attribute :description, :string
-        attribute :type_mappings, :string, collection: true
-        attribute :boolean_fields, :string, collection: true
-        attribute :null_handling, NullHandling
-        attribute :tables, TableDefinition, collection: true
-
-        yaml do
-          map "version", to: :version
-          map "description", to: :description
-          map "type_mappings", to: :type_mappings
-          map "boolean_fields", to: :boolean_fields
-          map "null_handling", to: :null_handling
-          map "tables", to: :tables
-        end
-
-        class << self
-          # Load configuration from YAML file
-          #
-          # @param config_path [String, nil] Path to configuration file
-          #   Defaults to config/qea_schema.yml
-          # @return [Configuration] The loaded configuration
-          # @raise [Errno::ENOENT] if config file not found
-          # @raise [Lutaml::Model::Error] if YAML is invalid
-          def load(config_path = nil)
-            config_path ||= default_config_path
-
-            unless File.exist?(config_path)
-              raise Errno::ENOENT,
-                    "Configuration file not found: #{config_path}"
-            end
-
-            yaml_content = File.read(config_path)
-            from_yaml(yaml_content)
-          end
-
-          # Get default configuration file path
-          #
-          # @return [String] Path to default config file
-          def default_config_path
-            File.expand_path("../../../../config/qea_schema.yml", __dir__)
-          end
-        end
-
-        # Get list of enabled tables
-        #
-        # @return [Array<TableDefinition>] Array of enabled table definitions
-        def enabled_tables
-          tables&.select(&:enabled) || []
-        end
-
-        # Get table configuration by table name
-        #
-        # @param table_name [String] The table name
-        # @return [TableDefinition, nil] The table definition
-        # or nil if not found
-        def table_config_for(table_name)
-          tables&.find { |t| t.table_name == table_name }
-        end
-
-        # Check if a table is enabled
-        #
-        # @param table_name [String] The table name
-        # @return [Boolean] true if table is enabled
-        def table_enabled?(table_name)
-          table = table_config_for(table_name)
-          table&.enabled == true
-        end
-
-        # Get all enabled table names
-        #
-        # @return [Array<String>] Array of enabled table names
-        def enabled_table_names
-          enabled_tables.map(&:table_name)
-        end
-
-        # Check if a field should be treated as boolean
-        #
-        # @param field_name [String] The field name
-        # @return [Boolean] true if field is in boolean_fields list
-        def boolean_field?(field_name)
-          boolean_fields&.include?(field_name) || false
-        end
-
-        # Get primary key for a table
-        #
-        # @param table_name [String] The table name
-        # @return [String, nil] The primary key column name
-        def primary_key_for(table_name)
-          table = table_config_for(table_name)
-          table&.primary_key
-        end
-
-        # Get collection name for a table
-        #
-        # @param table_name [String] The table name
-        # @return [String, nil] The collection name
-        def collection_name_for(table_name)
-          table = table_config_for(table_name)
-          table&.collection_name
-        end
-
-        # Convert empty strings to nil based on configuration
-        #
-        # @param value [String, nil] The value to convert
-        # @return [String, nil] The converted value
-        def convert_empty_string(value)
-          return value unless null_handling&.empty_string_as_null
-
-          value.nil? || value.empty? ? nil : value
-        end
-
-        # Check if zero should be treated as null
-        #
-        # @return [Boolean] true if zero should be converted to nil
-        def zero_as_null?
-          null_handling&.zero_as_null == true
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/services/database_loader.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Services
-      # DatabaseLoader orchestrates loading all EA tables into a Database
-      #
-      # This service loads all enabled tables from the QEA database,
-      # converts database rows to model instances, and populates a
-      # Database container with the results.
-      #
-      # @example Load a database
-      #   loader = DatabaseLoader.new("model.qea")
-      #   loader.on_progress do |table, current, total|
-      #     puts "Loading #{table}: #{current}/#{total}"
-      #   end
-      #   database = loader.load
-      #
-      # @example Load a single table
-      #   loader = DatabaseLoader.new("model.qea")
-      #   objects = loader.load_table("t_object")
-      class DatabaseLoader
-        # @return [String] Path to QEA file
-        attr_reader :qea_path
-
-        # @return [Configuration] Configuration instance
-        attr_reader :config
-
-        # Table name to model class mapping
-        MODEL_CLASSES = {
-          "t_object" => Models::EaObject,
-          "t_attribute" => Models::EaAttribute,
-          "t_operation" => Models::EaOperation,
-          "t_operationparams" => Models::EaOperationParam,
-          "t_connector" => Models::EaConnector,
-          "t_package" => Models::EaPackage,
-          "t_diagram" => Models::EaDiagram,
-          "t_diagramobjects" => Models::EaDiagramObject,
-          "t_diagramlinks" => Models::EaDiagramLink,
-          "t_objectconstraint" => Models::EaObjectConstraint,
-          "t_taggedvalue" => Models::EaTaggedValue,
-          "t_objectproperties" => Models::EaObjectProperty,
-          "t_attributetag" => Models::EaAttributeTag,
-          "t_xref" => Models::EaXref,
-          "t_document" => Models::EaDocument,
-          "t_script" => Models::EaScript,
-          "t_stereotypes" => Models::EaStereotype,
-          "t_datatypes" => Models::EaDatatype,
-          "t_constrainttypes" => Models::EaConstraintType,
-          "t_connectortypes" => Models::EaConnectorType,
-          "t_diagramtypes" => Models::EaDiagramType,
-          "t_objecttypes" => Models::EaObjectType,
-          "t_statustypes" => Models::EaStatusType,
-          "t_complexitytypes" => Models::EaComplexityType,
-        }.freeze
-
-        # Initialize loader
-        #
-        # @param qea_path [String] Path to QEA file
-        # @param config [Configuration, nil] Optional configuration
-        def initialize(qea_path, config = nil)
-          @qea_path = qea_path
-          @config = config || Configuration.load
-          @progress_callback = nil
-          @connection = Infrastructure::DatabaseConnection.new(qea_path)
-        end
-
-        # Set progress callback
-        #
-        # @yield [table_name, current, total] Progress information
-        # @yieldparam table_name [String] Current table being loaded
-        # @yieldparam current [Integer] Records loaded so far
-        # @yieldparam total [Integer] Total records in table
-        # @return [self]
-        def on_progress(&block)
-          @progress_callback = block
-          self
-        end
-
-        # Load entire database
-        #
-        # @return [Database] Populated database instance
-        # @raise [Errno::ENOENT] if QEA file not found
-        # @raise [SQLite3::Exception] if database access fails
-        def load
-          # Connect but don't use with_connection - we need to keep it open
-          @connection.connect unless @connection.connected?
-          db = @connection.connection
-
-          database = Database.new(@qea_path, db)
-
-          @config.enabled_tables.each do |table_def|
-            table_name = table_def.table_name
-            collection_name = table_def.collection_name
-
-            records = load_table_records(db, table_name)
-            database.add_collection(collection_name, records)
-          end
-
-          database.freeze
-        end
-
-        # Load a single table
-        #
-        # @param table_name [String] Table name to load
-        # @return [Array] Array of model instances
-        # @raise [ArgumentError] if table not configured or not enabled
-        def load_table(table_name) # rubocop:disable Metrics/MethodLength
-          table_def = @config.table_config_for(table_name)
-          unless table_def
-            raise ArgumentError,
-                  "Table #{table_name} not configured"
-          end
-          unless table_def.enabled
-            raise ArgumentError,
-                  "Table #{table_name} not enabled"
-          end
-
-          @connection.with_connection do |db|
-            load_table_records(db, table_name)
-          end
-        end
-
-        # Get quick statistics without full loading
-        #
-        # @return [Hash<String, Integer>] Table names to record counts
-        def quick_stats
-          stats = {}
-
-          @connection.with_connection do |db|
-            @config.enabled_tables.each do |table_def|
-              reader = Infrastructure::TableReader.new(db, table_def.table_name)
-              stats[table_def.collection_name] = reader.count
-            end
-          end
-
-          stats
-        end
-
-        private
-
-        # Load records for a table
-        #
-        # @param db [SQLite3::Database] Database connection
-        # @param table_name [String] Table name
-        # @return [Array] Array of model instances
-        def load_table_records(db, table_name) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          model_class = MODEL_CLASSES[table_name]
-          unless model_class
-            raise ArgumentError, "No model class for table #{table_name}"
-          end
-
-          reader = Infrastructure::TableReader.new(db, table_name)
-          total = reader.count
-          records = []
-
-          rows = reader.all
-          rows.each_with_index do |row, index|
-            record = model_class.from_db_row(row)
-            records << record if record
-            if @progress_callback
-              report_progress(table_name, index + 1,
-                              total)
-            end
-          rescue StandardError => e
-            # Log error but continue loading other records
-            warn "Error loading record from #{table_name}: #{e.message}"
-          end
-
-          records
-        end
-
-        # Report progress to callback
-        #
-        # @param table_name [String] Current table
-        # @param current [Integer] Current record count
-        # @param total [Integer] Total records
-        def report_progress(table_name, current, total)
-          @progress_callback.call(table_name, current, total)
-        rescue StandardError => e
-          warn "Error in progress callback: #{e.message}"
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/services.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Services
-      autoload :Configuration, "lutaml/qea/services/configuration"
-      autoload :DatabaseLoader, "lutaml/qea/services/database_loader"
-    end
-  end
-end

data/lib/lutaml/qea/validation/association_validator.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Validation
-      # Validates association/connector references
-      class AssociationValidator < BaseValidator
-        def validate
-          validate_object_references
-          validate_connector_endpoints
-        end
-
-        private
-
-        def validate_object_references
-          connectors.select(&:association?).each do |conn|
-            validate_start_object(conn)
-            validate_end_object(conn)
-          end
-        end
-
-        def validate_start_object(connector) # rubocop:disable Metrics/MethodLength
-          return if reference_exists?("t_object", "ea_object_id",
-                                      connector.start_object_id)
-
-          result.add_error(
-            category: :missing_reference,
-            entity_type: :association,
-            entity_id: connector.connector_id.to_s,
-            entity_name: connector.name || "Unnamed",
-            field: "start_object_id",
-            reference: connector.start_object_id.to_s,
-            message: "Start object #{connector.start_object_id} does not exist",
-          )
-        end
-
-        def validate_end_object(connector) # rubocop:disable Metrics/MethodLength
-          return if reference_exists?("t_object", "ea_object_id",
-                                      connector.end_object_id)
-
-          result.add_error(
-            category: :missing_reference,
-            entity_type: :association,
-            entity_id: connector.connector_id.to_s,
-            entity_name: connector.name || "Unnamed",
-            field: "end_object_id",
-            reference: connector.end_object_id.to_s,
-            message: "End object #{connector.end_object_id} does not exist",
-          )
-        end
-
-        def validate_connector_endpoints # rubocop:disable Metrics/MethodLength
-          connectors.each do |conn|
-            # Validate both endpoints exist
-            unless conn.start_object_id && conn.end_object_id
-              result.add_error(
-                category: :invalid_data,
-                entity_type: :connector,
-                entity_id: conn.connector_id.to_s,
-                entity_name: conn.name || "Unnamed",
-                message: "Connector missing start or end object reference",
-              )
-            end
-          end
-        end
-
-        def connectors
-          @connectors ||= context[:connectors] || []
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/validation/attribute_validator.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Validation
-      # Validates attribute references and structure
-      class AttributeValidator < BaseValidator
-        def validate
-          validate_parent_object_references
-          validate_type_references
-        end
-
-        private
-
-        def validate_parent_object_references # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          attributes.each do |attr|
-            unless reference_exists?("t_object", "ea_object_id",
-                                     attr.ea_object_id)
-              parent = database&.objects&.all&.find do |o|
-                o.ea_object_id == attr.ea_object_id
-              end
-              attr_location = if parent
-                                "#{resolve_class_path(
-                                  parent.ea_object_id,
-                                  parent.name,
-                                )}::#{attr.name}"
-                              else
-                                "Unknown::#{attr.name} " \
-                                  "(attribute_id: #{attr.id})"
-                              end
-              result.add_error(
-                category: :missing_reference,
-                entity_type: :attribute,
-                entity_id: attr.id.to_s,
-                entity_name: attr.name,
-                field: "ea_object_id",
-                reference: attr.ea_object_id.to_s,
-                message: "Parent object #{attr.ea_object_id} does not exist",
-                location: attr_location,
-              )
-            end
-          end
-        end
-
-        def validate_type_references # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          attributes.each do |attr|
-            next unless attr.classifier && !attr.classifier.empty?
-
-            # Classifier can be either an object ID or a primitive type name
-            next if primitive_type?(attr.classifier)
-            next if classifier_exists?(attr.classifier)
-
-            parent = database&.objects&.all&.find do |o|
-              o.ea_object_id == attr.ea_object_id
-            end
-            attr_location = if parent
-                              "#{resolve_class_path(parent.ea_object_id,
-                                                    parent.name)}::#{attr.name}"
-                            else
-                              "Unknown::#{attr.name} (attribute_id: #{attr.id})"
-                            end
-            result.add_warning(
-              category: :missing_reference,
-              entity_type: :attribute,
-              entity_id: attr.id.to_s,
-              entity_name: "#{parent&.name}.#{attr.name}",
-              field: "classifier",
-              reference: attr.classifier,
-              message: "Classifier '#{attr.classifier}' not found",
-              location: attr_location,
-            )
-          end
-        end
-
-        def attributes
-          @attributes ||= context[:attributes] || []
-        end
-
-        def classifier_exists?(classifier_id)
-          return false unless database
-
-          # Classifier field contains object_id, not name
-          database.objects.all.any? do |o|
-            o.ea_object_id.to_s == classifier_id.to_s
-          end
-        end
-
-        def primitive_type?(type_name)
-          # Common primitive and built-in types
-          primitives = %w[
-            Integer String Boolean Float Double Long Short Byte Char
-            Date Time DateTime Decimal
-            int string bool float double long short byte char
-            void Object Any
-          ]
-          primitives.include?(type_name)
-        end
-      end
-    end
-  end
-end