ea 0.1.0 → 0.1.4

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

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

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

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ea
+  module Qea
+    module Models
+      class BaseModel < Lutaml::Model::Serializable
+        def self.primary_key_column
+          raise NotImplementedError,
+                "#{self} must implement .primary_key_column"
+        end
+
+        def self.table_name
+          raise NotImplementedError,
+                "#{self} must implement .table_name"
+        end
+
+        def primary_key
+          public_send(self.class.primary_key_column)
+        end
+
+        # Stable sort key used by transformers that need to emit children in
+        # EA's tree-position order. Subclasses with a different field name
+        # (e.g., `pos` on t_attribute rows) override this.
+        # @return [Integer]
+        def sort_position
+          0
+        end
+
+        # Map of EA database column names to Ruby attribute names.
+        # Subclasses override this for non-trivial mappings.
+        # @return [Hash<String, Symbol>]
+        def self.column_map
+          {}
+        end
+
+        # Create instance from database row hash.
+        # Uses column_map for explicit mappings, falls back to lowercase.
+        # @param row [Hash] database row with string keys
+        # @return [BaseModel, nil] new instance or nil
+        def self.from_db_row(row)
+          return nil if row.nil?
+
+          mapping = column_map
+          attrs = row.transform_keys do |key|
+            if mapping.key?(key)
+              mapping[key]
+            else
+              key.to_s.downcase.to_sym
+            end
+          end
+
+          new(attrs)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Ea
+  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
+
+
+        COLUMN_MAP = {
+          "Object_ID" => :ea_object_id,
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        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
+
+        # @return [Integer] pos for attribute ordering within parent
+        def sort_position
+          pos || 0
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/models/ea_attribute_tag.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # EA Attribute Tag model
+      #
+      # Represents attribute-level tags (custom key-value metadata)
+      # in the t_attributetag table. These are metadata properties
+      # specific to GML/XML Schema encoding for attributes.
+      #
+      # @example Create from database row
+      #   row = {
+      #     "PropertyID" => 1,
+      #     "ElementID" => 367,
+      #     "Property" => "isMetadata",
+      #     "VALUE" => "false",
+      #     "NOTES" => nil,
+      #     "ea_guid" => "{GUID}"
+      #   }
+      #   tag = EaAttributeTag.from_db_row(row)
+      class EaAttributeTag < BaseModel
+        attribute :property_id, :integer
+        attribute :element_id, :integer
+        attribute :property, :string
+        attribute :value, :string
+        attribute :notes, :string
+        attribute :ea_guid, :string
+
+        # @return [Symbol] Primary key column name
+        def self.primary_key_column
+          :property_id
+        end
+
+        # @return [String] Database table name
+        def self.table_name
+          "t_attributetag"
+        end
+
+
+        COLUMN_MAP = {
+          "PropertyID" => :property_id,
+          "ElementID" => :element_id,
+        }.freeze
+
+        def self.column_map
+          COLUMN_MAP
+        end
+
+        # Get property name
+        #
+        # @return [String, nil] Property name
+        def name
+          property
+        end
+
+        # Get property value as string
+        #
+        # @return [String, nil] Property value
+        def property_value
+          value
+        end
+
+        # Parse boolean value
+        #
+        # @return [Boolean, nil] Boolean value if parseable, nil otherwise
+        def boolean_value
+          return nil if value.nil?
+
+          case value.downcase
+          when "true", "1", "yes"
+            true
+          when "false", "0", "no"
+            false
+          end
+        end
+
+        # Check if property is boolean type
+        #
+        # @return [Boolean] true if value is boolean
+        def boolean?
+          !boolean_value.nil?
+        end
+
+        # Parse integer value
+        #
+        # @return [Integer, nil] Integer value if parseable, nil otherwise
+        def integer_value
+          return nil if value.nil?
+
+          begin
+            Integer(value)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end