lutaml 0.10.18 → 0.11.2

data/lib/lutaml/qea/infrastructure/database_connection.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require "sqlite3"
-
-module Lutaml
-  module Qea
-    module Infrastructure
-      # DatabaseConnection manages the SQLite database connection lifecycle
-      # for QEA files (Enterprise Architect SQLite databases).
-      #
-      # @example Connect to a QEA file
-      #   conn = DatabaseConnection.new("model.qea")
-      #   conn.connect
-      #   # ... use connection
-      #   conn.close
-      #
-      # @example Using with_connection block
-      #   conn = DatabaseConnection.new("model.qea")
-      #   conn.with_connection do |db|
-      #     # ... use db
-      #   end
-      class DatabaseConnection
-        attr_reader :file_path, :connection
-
-        # Initialize a new database connection
-        #
-        # @param file_path [String] Path to the .qea file
-        # @raise [ArgumentError] if file_path is nil or empty
-        def initialize(file_path)
-          if file_path.nil? || file_path.empty?
-            raise ArgumentError,
-                  "file_path cannot be nil or empty"
-          end
-
-          @file_path = file_path
-          @connection = nil
-        end
-
-        # Connect to the database
-        #
-        # @return [SQLite3::Database] The database connection
-        # @raise [Errno::ENOENT] if the file does not exist
-        # @raise [SQLite3::Exception] if connection fails
-        def connect
-          unless File.exist?(@file_path)
-            raise Errno::ENOENT, "QEA file not found: #{@file_path}"
-          end
-
-          @connection = SQLite3::Database.new(@file_path, readonly: true)
-          @connection.results_as_hash = true
-          @connection
-        end
-
-        # Close the database connection
-        #
-        # @return [void]
-        def close
-          return unless @connection
-
-          @connection.close
-          @connection = nil
-        end
-
-        # Check if the connection is open
-        #
-        # @return [Boolean] true if connection is open
-        def connected?
-          !@connection.nil? && !@connection.closed?
-        end
-
-        # Execute a block with an active connection
-        #
-        # This method ensures the connection is properly opened and closed.
-        # If a connection already exists, it reuses it. Otherwise, it creates
-        # a new connection and closes it after the block executes.
-        #
-        # @yield [SQLite3::Database] The database connection
-        # @return [Object] The result of the block
-        # @raise [Errno::ENOENT] if the file does not exist
-        # @raise [SQLite3::Exception] if connection fails
-        #
-        # @example
-        #   conn = DatabaseConnection.new("model.qea")
-        #   result = conn.with_connection do |db|
-        #     db.execute("SELECT COUNT(*) FROM t_object")
-        #   end
-        def with_connection
-          should_close = !connected?
-
-          begin
-            connect unless connected?
-            yield @connection
-          ensure
-            close if should_close
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/infrastructure/schema_reader.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Infrastructure
-      # SchemaReader reads database schema information from a
-      # QEA SQLite database.
-      #
-      # This class is responsible for introspecting the database schema,
-      # including table names, column definitions, and metadata.
-      #
-      # @example Read schema information
-      #   reader = SchemaReader.new(db_connection)
-      #   tables = reader.tables
-      #   columns = reader.columns("t_object")
-      class SchemaReader
-        attr_reader :database
-
-        # Initialize a new schema reader
-        #
-        # @param database [SQLite3::Database] The database connection
-        # @raise [ArgumentError] if database is nil
-        def initialize(database)
-          raise ArgumentError, "database cannot be nil" if database.nil?
-
-          @database = database
-        end
-
-        # Get list of all table names in the database
-        #
-        # @param exclude_system [Boolean]
-        # Exclude SQLite system tables (default: true)
-        # @return [Array<String>] List of table names
-        def tables(exclude_system: true)
-          query = "SELECT name FROM sqlite_master WHERE type='table'"
-          query += " AND name NOT LIKE 'sqlite_%'" if exclude_system
-          query += " ORDER BY name"
-
-          @database.execute(query).map { |row| row["name"] }
-        end
-
-        # Get column information for a specific table
-        #
-        # @param table_name [String] The table name
-        # @return [Array<Hash>] Array of column information hashes
-        #   Each hash contains: name, type, notnull, dflt_value, pk
-        #
-        # @example
-        #   columns = reader.columns("t_object")
-        #   # => [
-        #   #   {"cid"=>0, "name"=>"Object_ID", "type"=>"INTEGER",
-        #   #    "notnull"=>1, "dflt_value"=>nil, "pk"=>1},
-        #   #   ...
-        #   # ]
-        def columns(table_name)
-          @database.execute("PRAGMA table_info(#{table_name})")
-        end
-
-        # Get just column names for a specific table
-        #
-        # @param table_name [String] The table name
-        # @return [Array<String>] List of column names
-        def column_names(table_name)
-          columns(table_name).map { |col| col["name"] }
-        end
-
-        # Check if a table exists in the database
-        #
-        # @param table_name [String] The table name to check
-        # @return [Boolean] true if table exists
-        def table_exists?(table_name)
-          result = @database.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
-            table_name,
-          )
-          !result.empty?
-        end
-
-        # Get primary key column name for a table
-        #
-        # @param table_name [String] The table name
-        # @return [String, nil] The primary key column name,
-        # or nil if no primary key
-        def primary_key(table_name)
-          pk_column = columns(table_name).find { |col| col["pk"] == 1 }
-          pk_column&.fetch("name", nil)
-        end
-
-        # Get table schema as CREATE TABLE statement
-        #
-        # @param table_name [String] The table name
-        # @return [String, nil] The CREATE TABLE SQL statement,
-        # or nil if table doesn't exist
-        def table_schema(table_name)
-          result = @database.execute(
-            "SELECT sql FROM sqlite_master WHERE type='table' AND name=?",
-            table_name,
-          )
-          result.first&.fetch("sql", nil)
-        end
-
-        # Get index information for a table
-        #
-        # @param table_name [String] The table name
-        # @return [Array<Hash>] Array of index information
-        def indexes(table_name)
-          @database.execute(
-            "SELECT name, sql FROM sqlite_master " \
-            "WHERE type='index' AND tbl_name=?",
-            table_name,
-          )
-        end
-
-        # Get row count for a table
-        #
-        # @param table_name [String] The table name
-        # @return [Integer] Number of rows in the table
-        def row_count(table_name)
-          result = @database.execute(
-            "SELECT COUNT(*) as count FROM #{table_name}",
-          )
-          result.first["count"]
-        end
-
-        # Get schema statistics for all tables
-        #
-        # @return [Hash] Hash mapping table names to row counts
-        def statistics
-          tables.to_h do |table_name|
-            [table_name, row_count(table_name)]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/infrastructure/table_reader.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Infrastructure
-      # TableReader reads data from a single table in a QEA SQLite database.
-      #
-      # This class provides methods to query and retrieve records from
-      # database tables with filtering and counting capabilities.
-      #
-      # @example Read all records from a table
-      #   reader = TableReader.new(db_connection, "t_object")
-      #   objects = reader.all
-      #
-      # @example Read with filtering
-      #   reader = TableReader.new(db_connection, "t_object")
-      #   classes = reader.where("Object_Type = ?", "Class")
-      class TableReader
-        attr_reader :database, :table_name
-
-        # Initialize a new table reader
-        #
-        # @param database [SQLite3::Database] The database connection
-        # @param table_name [String] The table name to read from
-        # @raise [ArgumentError] if database or table_name is nil
-        def initialize(database, table_name)
-          raise ArgumentError, "database cannot be nil" if database.nil?
-
-          if table_name.nil? || table_name.empty?
-            raise ArgumentError,
-                  "table_name cannot be nil or empty"
-          end
-
-          @database = database
-          @table_name = table_name
-        end
-
-        # Read all records from the table
-        #
-        # @param limit [Integer, nil] Maximum number of records to return
-        # (optional)
-        # @param offset [Integer, nil] Number of records to skip (optional)
-        # @return [Array<Hash>] Array of record hashes
-        #
-        # @example
-        #   reader.all
-        #   # => [{"Object_ID"=>1, "Name"=>"MyClass", ...}, ...]
-        #
-        # @example With limit
-        #   reader.all(limit: 10)
-        #   # => Returns first 10 records
-        def all(limit: nil, offset: nil) # rubocop:disable Metrics/MethodLength
-          query = "SELECT * FROM #{@table_name}"
-          params = []
-
-          if limit
-            query += " LIMIT ?"
-            params << limit
-          end
-
-          if offset
-            query += " OFFSET ?"
-            params << offset
-          end
-
-          @database.execute(query, params)
-        end
-
-        # Read records matching a WHERE clause
-        #
-        # @param conditions [String] The WHERE clause
-        # (without the WHERE keyword)
-        # @param values [Array] Values for parameterized query placeholders
-        # @param limit [Integer, nil] Maximum number of records
-        # to return (optional)
-        # @param offset [Integer, nil] Number of records to skip (optional)
-        # @return [Array<Hash>] Array of matching record hashes
-        #
-        # @example Simple filter
-        #   reader.where("Object_Type = ?", "Class")
-        #
-        # @example Multiple conditions
-        #   reader.where("Object_Type = ? AND Package_ID = ?", "Class", 5)
-        #
-        # @example With limit
-        #   reader.where("Object_Type = ?", "Class", limit: 10)
-        def where(conditions, *values, limit: nil, offset: nil) # rubocop:disable Metrics/MethodLength
-          query = "SELECT * FROM #{@table_name} WHERE #{conditions}"
-          params = values.flatten
-
-          if limit
-            query += " LIMIT ?"
-            params << limit
-          end
-
-          if offset
-            query += " OFFSET ?"
-            params << offset
-          end
-
-          @database.execute(query, params)
-        end
-
-        # Count all records in the table
-        #
-        # @return [Integer] Total number of records
-        def count
-          result = @database.execute(
-            "SELECT COUNT(*) as count FROM #{@table_name}",
-          )
-          result.first["count"]
-        end
-
-        # Count records matching a WHERE clause
-        #
-        # @param conditions [String] The WHERE clause
-        # (without the WHERE keyword)
-        # @param values [Array] Values for parameterized query placeholders
-        # @return [Integer] Number of matching records
-        #
-        # @example
-        #   reader.count_where("Object_Type = ?", "Class")
-        #   # => 42
-        def count_where(conditions, *values)
-          query = "SELECT COUNT(*) as count FROM #{@table_name} " \
-                  "WHERE #{conditions}"
-          result = @database.execute(query, values.flatten)
-          result.first["count"]
-        end
-
-        # Find a single record by primary key value
-        #
-        # @param primary_key_column [String] The primary key column name
-        # @param value [Object] The primary key value to search for
-        # @return [Hash, nil] The matching record hash, or nil if not found
-        #
-        # @example
-        #   reader.find_by_pk("Object_ID", 123)
-        #   # => {"Object_ID"=>123, "Name"=>"MyClass", ...}
-        def find_by_pk(primary_key_column, value)
-          query = "SELECT * FROM #{@table_name} " \
-                  "WHERE #{primary_key_column} = ? LIMIT 1"
-          result = @database.execute(query, [value])
-          result.first
-        end
-
-        # Find first record matching a WHERE clause
-        #
-        # @param conditions [String] The WHERE clause
-        # (without the WHERE keyword)
-        # @param values [Array] Values for parameterized query placeholders
-        # @return [Hash, nil] The first matching record hash,
-        # or nil if not found
-        #
-        # @example
-        #   reader.find_first("Name = ?", "MyClass")
-        #   # => {"Object_ID"=>123, "Name"=>"MyClass", ...}
-        def find_first(conditions, *values)
-          query = "SELECT * FROM #{@table_name} WHERE #{conditions} LIMIT 1"
-          result = @database.execute(query, values.flatten)
-          result.first
-        end
-
-        # Execute a custom SQL query on this table
-        #
-        # @param sql [String] The SQL query (should reference the table)
-        # @param params [Array] Parameters for the query
-        # @return [Array<Hash>] Query results
-        #
-        # @example
-        #   reader.execute_query(
-        #     "SELECT Name, COUNT(*) as count FROM #{reader.table_name}
-        #      GROUP BY Name"
-        #   )
-        def execute_query(sql, params = [])
-          @database.execute(sql, params)
-        end
-
-        # Check if any records match the given conditions
-        #
-        # @param conditions [String] The WHERE clause
-        # (without the WHERE keyword)
-        # @param values [Array] Values for parameterized query placeholders
-        # @return [Boolean] true if at least one record matches
-        #
-        # @example
-        #   reader.exists?("Name = ?", "MyClass")
-        #   # => true or false
-        def exists?(conditions, *values)
-          count_where(conditions, *values).positive?
-        end
-
-        # Read records with custom column selection
-        #
-        # @param columns [Array<String>] Column names to select
-        # @param conditions [String, nil] Optional WHERE clause
-        # @param values [Array] Values for parameterized query placeholders
-        # @param limit [Integer, nil] Maximum number of records to return
-        # @return [Array<Hash>] Array of record hashes with selected columns
-        #
-        # @example
-        #   reader.select(["Object_ID", "Name"], "Object_Type = ?", "Class")
-        #   # => [{"Object_ID"=>1, "Name"=>"Class1"}, ...]
-        def select(columns, conditions = nil, *values, limit: nil) # rubocop:disable Metrics/MethodLength
-          column_list = columns.join(", ")
-          query = "SELECT #{column_list} FROM #{@table_name}"
-
-          params = []
-          if conditions
-            query += " WHERE #{conditions}"
-            params = values.flatten
-          end
-
-          if limit
-            query += " LIMIT ?"
-            params << limit
-          end
-
-          @database.execute(query, params)
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/infrastructure.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Infrastructure
-      autoload :DatabaseConnection,
-               "lutaml/qea/infrastructure/database_connection"
-      autoload :SchemaReader, "lutaml/qea/infrastructure/schema_reader"
-      autoload :TableReader, "lutaml/qea/infrastructure/table_reader"
-    end
-  end
-end

data/lib/lutaml/qea/models/base_model.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Lutaml
-  module Qea
-    module Models
-      # Abstract base model for all QEA database models
-      # Provides common behavior and interface for domain models
-      class BaseModel < Lutaml::Model::Serializable
-        # Abstract method to be implemented by subclasses
-        # @return [Symbol] the primary key column name
-        def self.primary_key_column
-          raise NotImplementedError,
-                "#{self} must implement .primary_key_column"
-        end
-
-        # Abstract method to be implemented by subclasses
-        # @return [String] the database table name
-        def self.table_name
-          raise NotImplementedError,
-                "#{self} must implement .table_name"
-        end
-
-        # Returns the primary key value for this instance
-        # @return [Object] the primary key value
-        def primary_key
-          public_send(self.class.primary_key_column)
-        end
-
-        # Create instance from database row hash
-        # Handles case-insensitive column name mapping from database
-        # @param row [Hash] database row with string keys
-        # @return [BaseModel] new instance
-        def self.from_db_row(row)
-          return nil if row.nil?
-
-          # Convert database column names to attribute names
-          attrs = row.transform_keys do |key|
-            key.to_s.downcase.to_sym
-          end
-
-          new(attrs)
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/models/ea_attribute.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Models
-      # Represents an attribute from the t_attribute table in EA database
-      # This represents class attributes/properties
-      class EaAttribute < BaseModel
-        attribute :ea_object_id, Lutaml::Model::Type::Integer
-        attribute :name, Lutaml::Model::Type::String
-        attribute :scope, Lutaml::Model::Type::String
-        attribute :stereotype, Lutaml::Model::Type::String
-        attribute :containment, Lutaml::Model::Type::String
-        attribute :isstatic, Lutaml::Model::Type::Integer
-        attribute :iscollection, Lutaml::Model::Type::Integer
-        attribute :isordered, Lutaml::Model::Type::Integer
-        attribute :allowduplicates, Lutaml::Model::Type::Integer
-        attribute :lowerbound, Lutaml::Model::Type::String
-        attribute :upperbound, Lutaml::Model::Type::String
-        attribute :container, Lutaml::Model::Type::String
-        attribute :notes, Lutaml::Model::Type::String
-        attribute :derived, Lutaml::Model::Type::String
-        attribute :id, Lutaml::Model::Type::Integer
-        attribute :pos, Lutaml::Model::Type::Integer
-        attribute :genoption, Lutaml::Model::Type::String
-        attribute :length, Lutaml::Model::Type::Integer
-        attribute :precision, Lutaml::Model::Type::Integer
-        attribute :scale, Lutaml::Model::Type::Integer
-        attribute :const, Lutaml::Model::Type::Integer
-        attribute :style, Lutaml::Model::Type::String
-        attribute :classifier, Lutaml::Model::Type::String
-        attribute :default, Lutaml::Model::Type::String
-        attribute :type, Lutaml::Model::Type::String
-        attribute :ea_guid, Lutaml::Model::Type::String
-        attribute :styleex, Lutaml::Model::Type::String
-
-        def self.primary_key_column
-          :id
-        end
-
-        def self.table_name
-          "t_attribute"
-        end
-
-        # Create from database row
-        #
-        # @param row [Hash] Database row with string keys
-        # @return [EaAttribute, nil] New instance or nil if row is nil
-        def self.from_db_row(row) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          return nil if row.nil?
-
-          new(
-            ea_object_id: row["Object_ID"],
-            name: row["Name"],
-            scope: row["Scope"],
-            stereotype: row["Stereotype"],
-            containment: row["Containment"],
-            isstatic: row["IsStatic"],
-            iscollection: row["IsCollection"],
-            isordered: row["IsOrdered"],
-            allowduplicates: row["AllowDuplicates"],
-            lowerbound: row["LowerBound"],
-            upperbound: row["UpperBound"],
-            container: row["Container"],
-            notes: row["Notes"],
-            derived: row["Derived"],
-            id: row["ID"],
-            pos: row["Pos"],
-            genoption: row["GenOption"],
-            length: row["Length"],
-            precision: row["Precision"],
-            scale: row["Scale"],
-            const: row["Const"],
-            style: row["Style"],
-            classifier: row["Classifier"],
-            default: row["Default"],
-            type: row["Type"],
-            ea_guid: row["ea_guid"],
-            styleex: row["StyleEx"],
-          )
-        end
-
-        # Check if attribute is static
-        # @return [Boolean]
-        def static?
-          isstatic == 1
-        end
-
-        # Check if attribute is a collection
-        # @return [Boolean]
-        def collection?
-          iscollection == 1
-        end
-
-        # Check if attribute is ordered
-        # @return [Boolean]
-        def ordered?
-          isordered == 1
-        end
-
-        # Check if attribute allows duplicates
-        # @return [Boolean]
-        def allow_duplicates?
-          allowduplicates == 1
-        end
-
-        # Check if attribute is constant
-        # @return [Boolean]
-        def constant?
-          const == 1
-        end
-
-        # Check if attribute is public
-        # @return [Boolean]
-        def public?
-          scope&.downcase == "public"
-        end
-
-        # Check if attribute is private
-        # @return [Boolean]
-        def private?
-          scope&.downcase == "private"
-        end
-
-        # Check if attribute is protected
-        # @return [Boolean]
-        def protected?
-          scope&.downcase == "protected"
-        end
-      end
-    end
-  end
-end