lutaml 0.10.19 → 0.11.2

data/lib/lutaml/qea/factory/package_transformer.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      # Transforms EA packages to UML packages
-      class PackageTransformer < BaseTransformer
-        # Transform EA package to UML package
-        # @param ea_package [EaPackage] EA package model
-        # @return [Lutaml::Uml::Package] UML package
-        def transform(ea_package) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          return nil if ea_package.nil?
-
-          Lutaml::Uml::Package.new.tap do |pkg|
-            # Map basic properties
-            pkg.name = ea_package.name
-            pkg.xmi_id = normalize_guid_to_xmi_format(ea_package.ea_guid,
-                                                      "EAPK")
-
-            # Map definition/notes
-            pkg.definition = ea_package.notes unless
-              ea_package.notes.nil? || ea_package.notes.empty?
-
-            # Load and transform tagged values
-            pkg.tagged_values = load_tagged_values(ea_package.ea_guid)
-
-            # Load stereotype from t_xref
-            stereotype = load_stereotype(ea_package.ea_guid)
-            pkg.stereotype = [stereotype] if stereotype
-
-            # Note: Child packages and contents will be loaded separately
-            # to avoid circular dependencies and allow lazy loading
-            # Don't initialize collections - they have default values
-          end
-        end
-
-        # Transform and build complete package hierarchy
-        # @param ea_package [EaPackage] Root EA package
-        # @param include_children [Boolean] Whether to recursively load children
-        # @return [Lutaml::Uml::Package] Complete UML package with hierarchy
-        def transform_with_hierarchy(ea_package, include_children: true)
-          pkg = transform(ea_package)
-          return pkg unless include_children
-
-          # Load child packages
-          child_packages = load_child_packages(ea_package.package_id)
-          pkg.packages = child_packages.map do |child_pkg|
-            transform_with_hierarchy(child_pkg, include_children: true)
-          end
-
-          # Load package contents (classes, diagrams, etc.)
-          load_package_contents(pkg, ea_package.package_id)
-
-          pkg
-        end
-
-        private
-
-        # Load child packages
-        # @param parent_id [Integer] Parent package ID
-        # @return [Array<EaPackage>] Child packages
-        def load_child_packages(parent_id)
-          return [] if parent_id.nil?
-
-          database.child_packages_for(parent_id)
-            .sort_by { |p| p.tpos || 0 }
-        end
-
-        # Load package contents (objects and diagrams)
-        # @param pkg [Lutaml::Uml::Package] UML package to populate
-        # @param package_id [Integer] EA package ID
-        def load_package_contents(pkg, package_id)
-          return if package_id.nil?
-
-          # Load objects (classes, etc.) in this package
-          load_package_objects(pkg, package_id)
-
-          # Load diagrams in this package
-          load_package_diagrams(pkg, package_id)
-        end
-
-        # Load objects for a package
-        # @param pkg [Lutaml::Uml::Package] UML package
-        # @param package_id [Integer] Package ID
-        def load_package_objects(pkg, package_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          ea_objects = database.objects_in_package(package_id)
-
-          class_transformer = ClassTransformer.new(database)
-          enum_transformer = EnumTransformer.new(database)
-          data_type_transformer = DataTypeTransformer.new(database)
-          instance_transformer = InstanceTransformer.new(database)
-
-          ea_objects.each do |ea_obj|
-            if enum_object?(ea_obj)
-              uml_enum = enum_transformer.transform(ea_obj)
-              pkg.enums << uml_enum if uml_enum
-            elsif data_type_object?(ea_obj)
-              uml_dt = data_type_transformer.transform(ea_obj)
-              pkg.data_types << uml_dt if uml_dt
-            elsif class_object?(ea_obj)
-              uml_class = class_transformer.transform(ea_obj)
-              pkg.classes << uml_class if uml_class
-            elsif ea_obj.instance?
-              uml_instance = instance_transformer.transform(ea_obj)
-              pkg.instances << uml_instance if uml_instance
-            end
-          end
-        end
-
-        # Check if an EA object should be classified as an enum.
-        # EA stores enums as either object_type="Enumeration" or
-        # object_type="Class" with stereotype="enumeration".
-        def enum_object?(ea_obj)
-          ea_obj.enumeration? || stereotype_is?(ea_obj, "enumeration")
-        end
-
-        # Check if an EA object should be classified as a data type.
-        def data_type_object?(ea_obj)
-          ea_obj.data_type?
-        end
-
-        # Check if an EA object should be classified as a class.
-        def class_object?(ea_obj)
-          return false if enum_object?(ea_obj) || data_type_object?(ea_obj)
-
-          ea_obj.uml_class? || ea_obj.interface? ||
-            ea_obj.object_type == "Text" ||
-            ea_obj.object_type == "ProxyConnector"
-        end
-
-        # Check if an object's stereotype matches (case-insensitive).
-        def stereotype_is?(ea_obj, expected)
-          return false unless ea_obj.stereotype
-
-          ea_obj.stereotype.downcase == expected
-        end
-
-        # Load diagrams for a package
-        # @param pkg [Lutaml::Uml::Package] UML package
-        # @param package_id [Integer] Package ID
-        def load_package_diagrams(pkg, package_id)
-          diagram_transformer = DiagramTransformer.new(database)
-
-          ea_diagrams = database.diagrams_in_package(package_id)
-          pkg.diagrams = diagram_transformer.transform_collection(ea_diagrams)
-        end
-
-        # Load and transform tagged values for a package
-        # @param ea_guid [String] Element GUID
-        # @return [Array<Lutaml::Uml::TaggedValue>] UML tagged values
-        def load_tagged_values(ea_guid)
-          return [] if ea_guid.nil?
-          return [] unless database.tagged_values
-
-          # Filter tagged values for this element from the in-memory collection
-          ea_tags = database.tagged_values.select do |tag|
-            tag.element_id == ea_guid
-          end
-
-          # Transform to UML tagged values
-          tag_transformer = TaggedValueTransformer.new(database)
-          tag_transformer.transform_collection(ea_tags)
-        end
-
-        # Load stereotype from t_xref table
-        # @param ea_guid [String] Element GUID
-        # @return [String, nil] Stereotype value (as string to match XMI format)
-        def load_stereotype(ea_guid) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return nil if ea_guid.nil?
-          return nil unless database.xrefs
-
-          # Find stereotype xref from the in-memory collection
-          xref = database.xrefs.find do |x|
-            x.client == ea_guid &&
-              x.name == "Stereotypes" && x.type == "element property"
-          end
-
-          return nil unless xref
-
-          # Parse stereotype from Description field
-          # Format: @STEREO;Name=ApplicationSchema;FQName=GML::ApplicationSchema;@ENDSTEREO;
-          description = xref.description
-          return nil if description.nil? || description.empty?
-
-          # Extract the Name value from the @STEREO format
-          if description =~ /@STEREO;Name=([^;]+);/
-            return $1
-          end
-
-          nil
-        end
-
-        # Check if an object appears on any diagram
-        # @param object_id [Integer] Object ID
-        # @return [Boolean] True if object appears on a diagram
-        def appears_on_diagram?(object_id)
-          return false if object_id.nil?
-          return false unless database.diagram_objects
-
-          # Check if object appears in any diagram's objects
-          database.diagram_objects.any? do |dobj|
-            dobj.ea_object_id == object_id
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/factory/reference_resolver.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      # Resolves references between EA and UML elements
-      # Maps EA GUIDs to UML xmi_ids and maintains object relationships
-      class ReferenceResolver
-        # Initialize empty resolver
-        def initialize
-          @guid_to_element = {}
-          @object_id_to_name = {}
-        end
-
-        # Register EA GUID to UML element mapping
-        # @param ea_guid [String] EA GUID
-        # @param uml_element [Object] UML element with xmi_id
-        # @return [void]
-        def register(ea_guid, uml_element)
-          return if ea_guid.nil? || uml_element.nil?
-
-          @guid_to_element[normalize_guid(ea_guid)] = uml_element
-        end
-
-        # Register object ID to name mapping
-        # @param object_id [Integer] EA object ID
-        # @param name [String] Object name
-        # @return [void]
-        def register_object_name(object_id, name)
-          return if object_id.nil?
-
-          @object_id_to_name[object_id] = name
-        end
-
-        # Resolve EA GUID to UML element
-        # @param ea_guid [String] EA GUID
-        # @return [Object, nil] UML element or nil if not found
-        def resolve(ea_guid)
-          return nil if ea_guid.nil?
-
-          @guid_to_element[normalize_guid(ea_guid)]
-        end
-
-        # Get object name by object ID
-        # @param object_id [Integer] EA object ID
-        # @return [String, nil] Object name or nil if not found
-        def resolve_object_name(object_id)
-          return nil if object_id.nil?
-
-          @object_id_to_name[object_id]
-        end
-
-        # Get UML xmi_id by EA GUID
-        # @param ea_guid [String] EA GUID
-        # @return [String, nil] xmi_id or nil if not found
-        def resolve_xmi_id(ea_guid)
-          element = resolve(ea_guid)
-          element&.xmi_id
-        end
-
-        # Check if GUID is registered
-        # @param ea_guid [String] EA GUID
-        # @return [Boolean] True if registered
-        def registered?(ea_guid)
-          return false if ea_guid.nil?
-
-          @guid_to_element.key?(normalize_guid(ea_guid))
-        end
-
-        # Clear all mappings
-        # @return [void]
-        def clear
-          @guid_to_element.clear
-          @object_id_to_name.clear
-        end
-
-        # Get statistics
-        # @return [Hash] Statistics about registered elements
-        def stats
-          {
-            total_elements: @guid_to_element.size,
-            total_objects: @object_id_to_name.size,
-          }
-        end
-
-        private
-
-        # Normalize GUID format (remove braces, upcase)
-        # @param guid [String] GUID string
-        # @return [String] Normalized GUID
-        def normalize_guid(guid)
-          return guid if guid.nil?
-
-          guid.to_s.gsub(/[{}]/, "").upcase
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/factory/stereotype_loader.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      class StereotypeLoader
-        def initialize(database)
-          @database = database
-        end
-
-        def load_from_xref(ea_guid)
-          return nil if ea_guid.nil?
-          return nil unless @database.xrefs
-
-          xref = find_stereotype_xref(ea_guid)
-          return nil unless xref
-
-          extract_stereotype_name(xref.description)
-        end
-
-        private
-
-        def find_stereotype_xref(ea_guid)
-          @database.xrefs.find do |x|
-            x.client == ea_guid && x.name == "Stereotypes" &&
-              x.type == "element property"
-          end
-        end
-
-        def extract_stereotype_name(description)
-          return nil if description.nil? || description.empty?
-
-          if description =~ /@STEREO;Name=([^;]+);/
-            Regexp.last_match(1)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/factory/tagged_value_transformer.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      # Transforms EA TaggedValue to UML TaggedValue
-      #
-      # This transformer converts Enterprise Architect tagged value
-      # definitions (custom metadata) to standard UML TaggedValue objects.
-      #
-      # @example Transform a tagged value
-      #   ea_tag = Models::EaTaggedValue.new(
-      #     property_id: "{GUID}",
-      #     element_id: "{ELEMENT-GUID}",
-      #     base_class: "ASSOCIATION_SOURCE",
-      #     tag_value: "sequenceNumber|15$ea_notes=Unique integer..."
-      #   )
-      #   transformer = TaggedValueTransformer.new(database)
-      #   uml_tag = transformer.transform(ea_tag)
-      class TaggedValueTransformer < BaseTransformer
-        # Transform EA tagged value to UML TaggedValue
-        #
-        # @param ea_tag [Models::EaTaggedValue] EA tagged value model
-        # @return [Lutaml::Uml::TaggedValue, nil] UML tagged value or nil
-        def transform(ea_tag)
-          return nil unless ea_tag
-          return nil unless ea_tag.tag_name
-
-          Lutaml::Uml::TaggedValue.new.tap do |tag|
-            tag.name = ea_tag.tag_name
-            tag.value = ea_tag.parsed_value || ""
-            tag.notes = ea_tag.parsed_notes
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/qea/factory/transformer_registry.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      # Registry for EA to UML transformers
-      # Implements the Registry pattern for transformer lookup
-      class TransformerRegistry
-        class << self
-          # Get or initialize the registry
-          # @return [Hash] Registry hash
-          def registry
-            @registry ||= {}
-          end
-
-          # Register a transformer for an EA type
-          # @param ea_type [Symbol, String] EA model type
-          # @param transformer_class [Class] Transformer class
-          def register(ea_type, transformer_class)
-            registry[ea_type.to_sym] = transformer_class
-          end
-
-          # Get transformer for an EA type
-          # @param ea_type [Symbol, String] EA model type
-          # @return [Class, nil] Transformer class or nil if not found
-          def transformer_for(ea_type)
-            registry[ea_type.to_sym]
-          end
-
-          # Get all registered transformers
-          # @return [Hash] All registered transformers
-          def all_transformers
-            registry.dup
-          end
-
-          # Check if a transformer is registered for a type
-          # @param ea_type [Symbol, String] EA model type
-          # @return [Boolean] True if registered
-          def registered?(ea_type)
-            registry.key?(ea_type.to_sym)
-          end
-
-          # Clear all registrations (mainly for testing)
-          def clear
-            @registry = {}
-          end
-
-          # Reset to default registrations
-          def reset_defaults
-            clear
-            register_defaults
-          end
-
-          # Register default transformers
-          def register_defaults
-            # Object types
-            register(:class, ClassTransformer)
-            register(:interface, ClassTransformer)
-            register(:package, PackageTransformer)
-
-            # Connector types
-            register(:association, AssociationTransformer)
-            register(:generalization, GeneralizationTransformer)
-
-            # Other types
-            register(:attribute, AttributeTransformer)
-            register(:operation, OperationTransformer)
-            register(:diagram, DiagramTransformer)
-          end
-        end
-
-        # Initialize registry with default transformers
-        register_defaults
-      end
-    end
-  end
-end

data/lib/lutaml/qea/factory.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Qea
-    module Factory
-      autoload :BaseTransformer, "lutaml/qea/factory/base_transformer"
-      autoload :AssociationBuilder, "lutaml/qea/factory/association_builder"
-      autoload :AssociationTransformer,
-               "lutaml/qea/factory/association_transformer"
-      autoload :AttributeTagTransformer,
-               "lutaml/qea/factory/attribute_tag_transformer"
-      autoload :AttributeTransformer, "lutaml/qea/factory/attribute_transformer"
-      autoload :ClassTransformer, "lutaml/qea/factory/class_transformer"
-      autoload :ConstraintTransformer,
-               "lutaml/qea/factory/constraint_transformer"
-      autoload :DataTypeTransformer, "lutaml/qea/factory/data_type_transformer"
-      autoload :DiagramTransformer, "lutaml/qea/factory/diagram_transformer"
-      autoload :DocumentBuilder, "lutaml/qea/factory/document_builder"
-      autoload :EnumTransformer, "lutaml/qea/factory/enum_transformer"
-      autoload :GeneralizationBuilder,
-               "lutaml/qea/factory/generalization_builder"
-      autoload :GeneralizationTransformer,
-               "lutaml/qea/factory/generalization_transformer"
-      autoload :InstanceTransformer, "lutaml/qea/factory/instance_transformer"
-      autoload :ObjectPropertyTransformer,
-               "lutaml/qea/factory/object_property_transformer"
-      autoload :OperationTransformer, "lutaml/qea/factory/operation_transformer"
-      autoload :PackageTransformer, "lutaml/qea/factory/package_transformer"
-      autoload :ReferenceResolver, "lutaml/qea/factory/reference_resolver"
-      autoload :StereotypeLoader, "lutaml/qea/factory/stereotype_loader"
-      autoload :TaggedValueTransformer,
-               "lutaml/qea/factory/tagged_value_transformer"
-      autoload :TransformerRegistry, "lutaml/qea/factory/transformer_registry"
-      autoload :EaToUmlFactory, "lutaml/qea/factory/ea_to_uml_factory"
-    end
-  end
-end

data/lib/lutaml/qea/file_detector.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require "sqlite3"
-
-module Lutaml
-  module Qea
-    # Utility for detecting and validating QEA files
-    class FileDetector
-      # SQLite magic bytes
-      SQLITE_MAGIC = "SQLite format 3\x00"
-
-      # Required EA tables for valid QEA file
-      REQUIRED_EA_TABLES = %w[
-        t_object
-        t_attribute
-        t_connector
-        t_package
-      ].freeze
-
-      class << self
-        # Check if file is a QEA file
-        #
-        # @param path [String] File path
-        # @return [Boolean] True if file appears to be QEA
-        def qea_file?(path)
-          return false unless File.exist?(path)
-          return false unless File.file?(path)
-          return false unless path.end_with?(".qea")
-
-          # Quick check: is it SQLite?
-          sqlite_file?(path)
-        end
-
-        # Validate QEA file structure
-        #
-        # @param path [String] File path
-        # @return [Hash] Validation result with :valid, :errors, :warnings
-        #
-        # @example
-        #   result = FileDetector.validate_qea("model.qea")
-        #   if result[:valid]
-        #     puts "Valid QEA file"
-        #   else
-        #     puts "Errors: #{result[:errors]}"
-        #   end
-        def validate_qea(path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          errors = []
-          warnings = []
-
-          # Check file exists
-          unless File.exist?(path)
-            return {
-              valid: false,
-              errors: ["File not found: #{path}"],
-              warnings: [],
-            }
-          end
-
-          # Check file extension
-          unless path.end_with?(".qea")
-            warnings << "File does not have .qea extension"
-          end
-
-          # Check SQLite format
-          unless sqlite_file?(path)
-            errors << "File is not a valid SQLite database"
-            return { valid: false, errors: errors, warnings: warnings }
-          end
-
-          # Check for EA tables
-          begin
-            db = SQLite3::Database.new(path, readonly: true)
-            tables = get_table_names(db)
-
-            REQUIRED_EA_TABLES.each do |required_table|
-              unless tables.include?(required_table)
-                errors << "Missing required EA table: #{required_table}"
-              end
-            end
-
-            # Check for data
-            if tables.include?("t_object")
-              count = db.execute("SELECT COUNT(*) FROM t_object").first.first
-              if count.zero?
-                warnings << "No objects found in t_object table"
-              end
-            end
-          rescue SQLite3::Exception => e
-            errors << "Failed to open database: #{e.message}"
-          ensure
-            db&.close
-          end
-
-          {
-            valid: errors.empty?,
-            errors: errors,
-            warnings: warnings,
-          }
-        end
-
-        # Get file information
-        #
-        # @param path [String] File path
-        # @return [Hash] File information
-        #
-        # @example
-        #   info = FileDetector.file_info("model.qea")
-        #   puts "Size: #{info[:size_mb]} MB"
-        #   puts "Tables: #{info[:table_count]}"
-        def file_info(path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return { error: "File not found" } unless File.exist?(path)
-
-          info = {
-            path: path,
-            size_bytes: File.size(path),
-            size_mb: (File.size(path) / 1024.0 / 1024.0).round(2),
-            modified: File.mtime(path),
-            is_qea: qea_file?(path),
-          }
-
-          if sqlite_file?(path)
-            begin
-              db = SQLite3::Database.new(path, readonly: true)
-              tables = get_table_names(db)
-              info[:is_sqlite] = true
-              info[:table_count] = tables.size
-              info[:has_ea_tables] = REQUIRED_EA_TABLES.all? do |t|
-                tables.include?(t)
-              end
-
-              # Get record counts for key tables
-              if tables.include?("t_object")
-                info[:object_count] =
-                  db.execute("SELECT COUNT(*) FROM t_object").first.first
-              end
-              if tables.include?("t_package")
-                info[:package_count] =
-                  db.execute("SELECT COUNT(*) FROM t_package").first.first
-              end
-            rescue SQLite3::Exception => e
-              info[:error] = e.message
-            ensure
-              db&.close
-            end
-          else
-            info[:is_sqlite] = false
-          end
-
-          info
-        end
-
-        private
-
-        # Check if file is SQLite database
-        #
-        # @param path [String] File path
-        # @return [Boolean] True if SQLite database
-        def sqlite_file?(path)
-          File.open(path, "rb") do |f|
-            magic = f.read(16)
-            magic == SQLITE_MAGIC
-          end
-        rescue StandardError
-          false
-        end
-
-        # Get table names from database
-        #
-        # @param db [SQLite3::Database] Database connection
-        # @return [Array<String>] Table names
-        def get_table_names(db)
-          db.execute("SELECT name FROM sqlite_master WHERE type='table'")
-            .flatten
-        end
-      end
-    end
-  end
-end