lutaml 0.10.18 → 0.11.2

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

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-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/models.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Lutaml
-  module Qea
-    module Models
-      autoload :BaseModel, "lutaml/qea/models/base_model"
-      autoload :EaAttribute, "lutaml/qea/models/ea_attribute"
-      autoload :EaAttributeTag, "lutaml/qea/models/ea_attribute_tag"
-      autoload :EaComplexityType, "lutaml/qea/models/ea_complexity_type"
-      autoload :EaConnector, "lutaml/qea/models/ea_connector"
-      autoload :EaConnectorType, "lutaml/qea/models/ea_connector_type"
-      autoload :EaConstraintType, "lutaml/qea/models/ea_constraint_type"
-      autoload :EaDatatype, "lutaml/qea/models/ea_datatype"
-      autoload :EaDiagram, "lutaml/qea/models/ea_diagram"
-      autoload :EaDiagramLink, "lutaml/qea/models/ea_diagram_link"
-      autoload :EaDiagramObject, "lutaml/qea/models/ea_diagram_object"
-      autoload :EaDiagramType, "lutaml/qea/models/ea_diagram_type"
-      autoload :EaDocument, "lutaml/qea/models/ea_document"
-      autoload :EaObject, "lutaml/qea/models/ea_object"
-      autoload :EaObjectConstraint, "lutaml/qea/models/ea_object_constraint"
-      autoload :EaObjectProperty, "lutaml/qea/models/ea_object_property"
-      autoload :EaObjectType, "lutaml/qea/models/ea_object_type"
-      autoload :EaOperation, "lutaml/qea/models/ea_operation"
-      autoload :EaOperationParam, "lutaml/qea/models/ea_operation_param"
-      autoload :EaPackage, "lutaml/qea/models/ea_package"
-      autoload :EaScript, "lutaml/qea/models/ea_script"
-      autoload :EaStatusType, "lutaml/qea/models/ea_status_type"
-      autoload :EaStereotype, "lutaml/qea/models/ea_stereotype"
-      autoload :EaTaggedValue, "lutaml/qea/models/ea_tagged_value"
-      autoload :EaXref, "lutaml/qea/models/ea_xref"
-    end
-  end
-end

data/lib/lutaml/qea/parser.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,215 +0,0 @@
-# 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.public_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.public_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, &)
-          where(conditions, &).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, &)
-          !where(conditions, &).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, &)
-          where(conditions, &).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.to_h do |attr|
-              [attr, record.public_send(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.public_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.public_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.public_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

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-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