lutaml 0.9.43 → 0.10.0

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative "base_model"
+
+module Lutaml
+  module Qea
+    module Models
+      # Represents a cross-reference from the t_xref table in EA database
+      # Stores cross-references for stereotypes, properties, and relationships
+      # between UML elements
+      class EaXref < BaseModel
+        attribute :xref_id, Lutaml::Model::Type::String
+        attribute :name, Lutaml::Model::Type::String
+        attribute :xref_type, Lutaml::Model::Type::String
+        attribute :client, Lutaml::Model::Type::String
+        attribute :supplier, Lutaml::Model::Type::String
+        attribute :description, Lutaml::Model::Type::String
+
+        def self.primary_key_column
+          :xref_id
+        end
+
+        def self.table_name
+          "t_xref"
+        end
+
+        # Create from database row
+        #
+        # @param row [Hash] Database row with string keys
+        # @return [EaXref, nil] New instance or nil if row is nil
+        def self.from_db_row(row)
+          return nil if row.nil?
+
+          new(
+            xref_id: row["XrefID"],
+            name: row["Name"],
+            xref_type: row["Type"],
+            client: row["Client"],
+            supplier: row["Supplier"],
+            description: row["Description"],
+          )
+        end
+
+        # Convenience aliases
+        alias_method :id, :xref_id
+        alias_method :type, :xref_type
+
+        # Parse the Description field into structured data
+        #
+        # @return [Hash] Parsed description data
+        def parsed_description
+          return @parsed_description if defined?(@parsed_description)
+
+          @parsed_description = parse_description_field(description)
+        end
+
+        # Check if this xref is for stereotypes
+        # @return [Boolean]
+        def stereotype?
+          name == "Stereotypes" || description&.include?("@STEREO")
+        end
+
+        # Check if this xref is for custom properties
+        # @return [Boolean]
+        def custom_property?
+          !description&.include?("@STEREO") && !description&.include?("@TAG")
+        end
+
+        # Check if this xref is for element properties
+        # @return [Boolean]
+        def element_property?
+          xref_type == "element property"
+        end
+
+        # Check if this xref is for connector properties
+        # @return [Boolean]
+        def connector_property?
+          xref_type&.include?("connector") && xref_type.include?("property")
+        end
+
+        # Check if this xref is for diagram properties
+        # @return [Boolean]
+        def diagram_property?
+          xref_type == "diagram properties"
+        end
+
+        # Check if this xref is for attribute properties
+        # @return [Boolean]
+        def attribute_property?
+          xref_type == "attribute property"
+        end
+
+        private
+
+        # Parse Description field with various formats
+        #
+        # Formats:
+        # - @STEREO;Name=X;GUID={...};
+        # - @TAG;Name=X;Value=Y;GUID={...};
+        # - key=value;key=value;
+        #
+        # @param desc [String] Description field content
+        # @return [Hash] Parsed data
+        def parse_description_field(desc) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return {} if desc.nil? || desc.empty?
+
+          result = { raw: desc }
+
+          # Detect format
+          if desc.start_with?("@STEREO")
+            result[:format] = :stereotype
+            result[:data] = parse_stereo_format(desc)
+          elsif desc.start_with?("@TAG")
+            result[:format] = :tag
+            result[:data] = parse_tag_format(desc)
+          else
+            result[:format] = :key_value
+            result[:data] = parse_key_value_format(desc)
+          end
+
+          result
+        end
+
+        # Parse @STEREO format
+        # Example: @STEREO;Name=FeatureType;GUID={ABC...};
+        def parse_stereo_format(desc)
+          data = {}
+          parts = desc.sub(/^@STEREO;/, "").split(";")
+
+          parts.each do |part|
+            next if part.empty?
+
+            key, value = part.split("=", 2)
+            data[key.downcase.to_sym] = value if key && value
+          end
+
+          data
+        end
+
+        # Parse @TAG format
+        # Example: @TAG;Name=author;Value=John;GUID={...};
+        def parse_tag_format(desc)
+          data = {}
+          parts = desc.sub(/^@TAG;/, "").split(";")
+
+          parts.each do |part|
+            next if part.empty?
+
+            key, value = part.split("=", 2)
+            data[key.downcase.to_sym] = value if key && value
+          end
+
+          data
+        end
+
+        # Parse key=value format
+        # Example: aggregation=composite;direction=source;
+        def parse_key_value_format(desc)
+          data = {}
+          parts = desc.split(";")
+
+          parts.each do |part|
+            next if part.empty?
+
+            key, value = part.split("=", 2)
+            data[key.downcase.to_sym] = value if key && value
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/qea/parser.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../qea"
+require_relative "services/database_loader"
+require_relative "factory/ea_to_uml_factory"
+
+module Lutaml
+  module Qea
+    # Parser class provides backward compatibility wrapper for Qea.parse
+    #
+    # This class exists for compatibility with older code that uses
+    # Qea::Parser.parse instead of the newer Qea.parse method.
+    #
+    # For validation use cases, this returns both database and document.
+    # For simple parsing, use Qea.parse directly which returns just document.
+    #
+    # @example Parse a QEA file for validation
+    #   result = Lutaml::Qea::Parser.new.parse("model.qea")
+    #   document = result[:document]
+    #   database = result[:database]
+    #
+    # @see Qea.parse
+    class Parser
+      class << self
+        # Parse a QEA file and return document only
+        #
+        # This is a backward compatibility wrapper that delegates to Qea.parse
+        #
+        # @param qea_path [String] Path to the .qea file
+        # @param options [Hash] Transformation options
+        # @return [Lutaml::Uml::Document] Complete UML document
+        #
+        # @see Qea.parse
+        def parse(qea_path, options = {})
+          Qea.parse(qea_path, options)
+        end
+      end
+
+      # Instance method for compatibility with test expectations
+      # @param qea_path [String] Path to the .qea file
+      # @param options [Hash] Transformation options
+      # @return [Hash] Hash with :database and :document keys
+      def parse(qea_path, options = {}) # rubocop:disable Metrics/MethodLength
+        # Load database
+        config = options[:config]
+        loader = Services::DatabaseLoader.new(qea_path, config)
+        database = loader.load
+
+        # Create document
+        factory = Factory::EaToUmlFactory.new(database, options)
+        document = factory.create_document
+
+        # Return both for validation support
+        {
+          database: database,
+          document: document,
+        }
+      end
+    end
+  end
+end

data/lib/lutaml/qea/repositories/base_repository.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Qea
+    module Repositories
+      # Base repository for querying model collections
+      #
+      # This class provides common query methods for all model repositories.
+      # Subclasses can extend with model-specific query methods.
+      #
+      # @example Using base repository
+      #   repository = BaseRepository.new(records)
+      #   all_records = repository.all
+      #   record = repository.find(123)
+      #   filtered = repository.where { |r| r.name == "Test" }
+      class BaseRepository
+        include Enumerable
+
+        # @return [Array] The collection of records
+        attr_reader :records
+
+        # Initialize repository with a collection
+        #
+        # @param records [Array] Array of model instances
+        def initialize(records)
+          @records = records.freeze
+        end
+
+        # Iterates over all records
+        #
+        # @yield [record] Each record in the collection
+        # @return [Enumerator] if no block given
+        def each(&block)
+          return to_enum(:each) unless block
+
+          @records.each(&block)
+        end
+
+        # Get all records
+        #
+        # @return [Array] All records in the collection
+        def all
+          @records
+        end
+
+        # Find a record by primary key
+        #
+        # @param id [Object] Primary key value
+        # @return [Object, nil] The record or nil if not found
+        def find(id)
+          @records.find { |record| record.primary_key == id }
+        end
+
+        # Find a record by key and id
+        #
+        # @param key [Symbol] key attribute name
+        # @param id [Object] key value
+        # @return [Object, nil] The record or nil if not found
+        def find_by_key(key, id)
+          @records.find { |record| record.send(key) == id }
+        end
+
+        # Filter records by conditions
+        #
+        # @param conditions [Hash] Hash of attribute/value pairs
+        # @yield [record] Optional block for custom filtering
+        # @yieldparam record [Object] Each record
+        # @yieldreturn [Boolean] true to include record
+        # @return [Array] Filtered records
+        #
+        # @example Hash conditions
+        #   repository.where(name: "Test", type: "Class")
+        #
+        # @example Block condition
+        #   repository.where { |r| r.name.start_with?("Test") }
+        def where(conditions = nil, &block) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          if block
+            @records.select(&block)
+          elsif conditions.is_a?(Hash)
+            @records.select do |record|
+              conditions.all? do |attr, value|
+                record.respond_to?(attr) && record.send(attr) == value
+              end
+            end
+          else
+            @records
+          end
+        end
+
+        # Count records
+        #
+        # @param conditions [Hash, nil] Optional conditions to filter
+        # @yield [record] Optional block for custom filtering
+        # @return [Integer] Number of records
+        #
+        # @example Count all
+        #   repository.count
+        #
+        # @example Count with conditions
+        #   repository.count(type: "Class")
+        #
+        # @example Count with block
+        #   repository.count { |r| r.name.include?("Test") }
+        def count(conditions = nil, &block)
+          if block || conditions
+            where(conditions, &block).size
+          else
+            @records.size
+          end
+        end
+
+        # Find first record matching conditions
+        #
+        # @param conditions [Hash, nil] Optional conditions
+        # @yield [record] Optional block for custom filtering
+        # @return [Object, nil] First matching record or nil
+        #
+        # @example
+        #   repository.find_first(name: "Test")
+        #   repository.find_first { |r| r.name.start_with?("Test") }
+        def find_first(conditions = nil, &block)
+          where(conditions, &block).first
+        end
+
+        # Check if any records match conditions
+        #
+        # @param conditions [Hash, nil] Optional conditions
+        # @yield [record] Optional block for custom filtering
+        # @return [Boolean] true if any records match
+        def any?(conditions = nil, &block)
+          !where(conditions, &block).empty?
+        end
+
+        # Check if no records match conditions
+        #
+        # @param conditions [Hash, nil] Optional conditions
+        # @yield [record] Optional block for custom filtering
+        # @return [Boolean] true if no records match
+        def none?(conditions = nil, &block)
+          where(conditions, &block).empty?
+        end
+
+        # Select specific attributes from records
+        #
+        # @param attributes [Array<Symbol>] Attribute names to select
+        # @return [Array<Hash>] Array of hashes with selected attributes
+        #
+        # @example
+        #   repository.pluck(:id, :name)
+        #   # => [{id: 1, name: "Test"}, {id: 2, name: "Other"}]
+        def pluck(*attributes)
+          @records.map do |record|
+            attributes.each_with_object({}) do |attr, hash|
+              hash[attr] = record.send(attr) if record.respond_to?(attr)
+            end
+          end
+        end
+
+        # Group records by an attribute
+        #
+        # @param attribute [Symbol] Attribute name to group by
+        # @return [Hash] Hash with attribute values as keys, arrays as values
+        #
+        # @example
+        #   repository.group_by(:type)
+        #   # => {"Class" => [obj1, obj2], "Interface" => [obj3]}
+        def group_by(attribute)
+          @records.group_by { |record| record.send(attribute) }
+        end
+
+        # Sort records by an attribute
+        #
+        # @param attribute [Symbol] Attribute name to sort by
+        # @param order [Symbol] :asc or :desc (default: :asc)
+        # @return [Array] Sorted records
+        #
+        # @example
+        #   repository.order_by(:name)
+        #   repository.order_by(:created_at, :desc)
+        def order_by(attribute, order = :asc)
+          sorted = @records.sort_by { |record| record.send(attribute) }
+          order == :desc ? sorted.reverse : sorted
+        end
+
+        # Get unique values for an attribute
+        #
+        # @param attribute [Symbol] Attribute name
+        # @return [Array] Unique values
+        #
+        # @example
+        #   repository.distinct(:type)
+        #   # => ["Class", "Interface", "Component"]
+        def distinct(attribute)
+          @records.map { |record| record.send(attribute) }.uniq
+        end
+
+        # Check if repository is empty
+        #
+        # @return [Boolean] true if no records
+        def empty?
+          @records.empty?
+        end
+
+        # Get the size of the collection
+        #
+        # @return [Integer] Number of records
+        def size
+          @records.size
+        end
+
+        alias length size
+      end
+    end
+  end
+end

data/lib/lutaml/qea/repositories/object_repository.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative "base_repository"
+
+module Lutaml
+  module Qea
+    module Repositories
+      # Repository for EaObject collection with type-specific queries
+      #
+      # This repository provides convenient methods for querying objects
+      # by type, package, and other common criteria.
+      #
+      # @example Query by type
+      #   classes = repository.find_by_type("Class")
+      #   interfaces = repository.interfaces
+      #
+      # @example Query by package
+      #   pkg_objects = repository.find_by_package(5)
+      class ObjectRepository < BaseRepository
+        # Find objects by type
+        #
+        # @param object_type [String] The object type
+        # (e.g., "Class", "Interface")
+        # @return [Array<Models::EaObject>] Matching objects
+        #
+        # @example
+        #   repository.find_by_type("Class")
+        #   repository.find_by_type("Interface")
+        def find_by_type(object_type)
+          where(object_type: object_type)
+        end
+
+        # Find objects by package ID
+        #
+        # @param package_id [Integer] The package ID
+        # @return [Array<Models::EaObject>] Objects in the package
+        def find_by_package(package_id)
+          where(package_id: package_id)
+        end
+
+        # Find objects by stereotype
+        #
+        # @param stereotype [String] The stereotype name
+        # @return [Array<Models::EaObject>] Objects with the stereotype
+        def find_by_stereotype(stereotype)
+          where(stereotype: stereotype)
+        end
+
+        # Get all UML classes
+        #
+        # @return [Array<Models::EaObject>] All Class objects
+        def classes
+          find_by_type("Class")
+        end
+
+        # Get all interfaces
+        #
+        # @return [Array<Models::EaObject>] All Interface objects
+        def interfaces
+          find_by_type("Interface")
+        end
+
+        # Get all enumerations
+        #
+        # @return [Array<Models::EaObject>] All Enumeration objects
+        def enumerations
+          find_by_type("Enumeration")
+        end
+
+        # Get all components
+        #
+        # @return [Array<Models::EaObject>] All Component objects
+        def components
+          find_by_type("Component")
+        end
+
+        # Get all data types
+        #
+        # @return [Array<Models::EaObject>] All DataType objects
+        def data_types
+          find_by_type("DataType")
+        end
+
+        # Get all packages
+        #
+        # @return [Array<Models::EaObject>] All Package objects
+        def packages
+          find_by_type("Package")
+        end
+
+        # Get all abstract objects
+        #
+        # @return [Array<Models::EaObject>] All abstract objects
+        def abstract_objects
+          where(&:abstract?)
+        end
+
+        # Get all root objects
+        #
+        # @return [Array<Models::EaObject>] All root objects
+        def root_objects
+          where(&:root?)
+        end
+
+        # Get all leaf objects
+        #
+        # @return [Array<Models::EaObject>] All leaf objects
+        def leaf_objects
+          where(&:leaf?)
+        end
+
+        # Find objects by name pattern
+        #
+        # @param pattern [String, Regexp] Name pattern to match
+        # @return [Array<Models::EaObject>] Matching objects
+        #
+        # @example String match
+        #   repository.find_by_name("MyClass")
+        #
+        # @example Regex match
+        #   repository.find_by_name(/^Test/)
+        def find_by_name(pattern)
+          if pattern.is_a?(Regexp)
+            where { |obj| obj.name =~ pattern }
+          else
+            where(name: pattern)
+          end
+        end
+
+        # Get objects created after a date
+        #
+        # @param date [String] Date in ISO format
+        # @return [Array<Models::EaObject>] Objects created after date
+        def created_after(date)
+          where { |obj| obj.createddate && obj.createddate > date }
+        end
+
+        # Get objects modified after a date
+        #
+        # @param date [String] Date in ISO format
+        # @return [Array<Models::EaObject>] Objects modified after date
+        def modified_after(date)
+          where { |obj| obj.modifieddate && obj.modifieddate > date }
+        end
+
+        # Get statistics by object type
+        #
+        # @return [Hash<String, Integer>] Count by object type
+        #
+        # @example
+        #   repository.type_statistics
+        #   # => {"Class" => 42, "Interface" => 15, ...}
+        def type_statistics
+          group_by(:object_type).transform_values(&:size)
+        end
+
+        # Get statistics by package
+        #
+        # @return [Hash<Integer, Integer>] Count by package ID
+        def package_statistics
+          group_by(:package_id).transform_values(&:size)
+        end
+
+        # Get all object types in the collection
+        #
+        # @return [Array<String>] Unique object types
+        def object_types
+          distinct(:object_type).compact
+        end
+
+        # Get all stereotypes in the collection
+        #
+        # @return [Array<String>] Unique stereotypes
+        def stereotypes
+          distinct(:stereotype).compact
+        end
+
+        # Find objects by visibility
+        #
+        # @param visibility [String] Visibility (e.g., "Public", "Private")
+        # @return [Array<Models::EaObject>] Objects with the visibility
+        def find_by_visibility(visibility)
+          where(visibility: visibility)
+        end
+
+        # Get public objects
+        #
+        # @return [Array<Models::EaObject>] All public objects
+        def public_objects
+          find_by_visibility("Public")
+        end
+
+        # Get private objects
+        #
+        # @return [Array<Models::EaObject>] All private objects
+        def private_objects
+          find_by_visibility("Private")
+        end
+
+        # Get protected objects
+        #
+        # @return [Array<Models::EaObject>] All protected objects
+        def protected_objects
+          find_by_visibility("Protected")
+        end
+
+        # Search objects by name or alias
+        #
+        # @param query [String] Search query
+        # @return [Array<Models::EaObject>] Matching objects
+        def search(query)
+          query_downcase = query.downcase
+          where do |obj|
+            obj.name&.downcase&.include?(query_downcase) ||
+              obj.alias&.downcase&.include?(query_downcase)
+          end
+        end
+      end
+    end
+  end
+end