ea 0.1.0 → 0.1.4

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "yaml"
+
+module Ea
+  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/ea/qea/services/database_loader.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Ea
+  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 ArgumentError, TypeError, EncodingError => e
+            warn "Error loading record from #{table_name}: #{e.message}"
+          rescue StandardError => e
+            # Catch-all for record-level failures: skip bad records,
+            # don't abort the entire load. Connection-level errors propagate.
+            warn "Unexpected 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
+          # Progress callbacks are user-supplied; isolate their failures from
+          # the load pipeline. The callback's contract is "best effort".
+          warn "Error in progress callback: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/services.rb

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

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ea
+  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/ea/qea/validation/attribute_validator.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Ea
+  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
+
+      end
+    end
+  end
+end