ea 0.1.0 → 0.1.4

data/lib/ea/transformations/parsers/qea_parser.rb

@@ -0,0 +1,401 @@
+# frozen_string_literal: true
+
+module Ea
+  module Transformations
+    module Parsers
+      # QEA Parser implements the BaseParser interface for Enterprise Architect
+      # database files.
+      #
+      # This parser wraps the existing Ea::Qea functionality and adapts it
+      # to the new unified transformation architecture. It provides enhanced
+      # error handling, progress tracking, and configuration integration.
+      class QeaParser < BaseParser
+        # @return [Ea::Qea::Database] Loaded QEA database
+        attr_reader :qea_database
+
+        # @return [Hash] Database statistics
+        attr_reader :database_stats
+
+        # Get parser format name
+        #
+        # @return [String] Human-readable format name
+        def format_name
+          "Enterprise Architect Database (QEA)"
+        end
+
+        # Get list of supported file extensions
+        #
+        # @return [Array<String>] List of extensions
+        def supported_extensions
+          [".qea", ".eap", ".eapx"]
+        end
+
+        def content_patterns
+          [/^SQLite format/]
+        end
+
+        def priority
+          90
+        end
+
+        protected
+
+        # Core parsing implementation for QEA files
+        #
+        # @param file_path [String] Path to the QEA file
+        # @return [Lutaml::Uml::Document] Parsed UML document
+        def parse_internal(file_path)
+          # Validate QEA file format
+          validate_qea_format!(file_path)
+
+          # Load QEA database with progress tracking
+          @qea_database = load_qea_database(file_path)
+
+          # Get database statistics
+          @database_stats = @qea_database.stats
+
+          # Transform to UML document using existing factory
+          document = transform_qea_to_uml(@qea_database, file_path)
+
+          # Post-process document
+          post_process_qea_document(document, file_path)
+
+          document
+        end
+
+        # Hook called before parsing starts
+        #
+        # @param file_path [String] Path to the file being parsed
+        # @return [void]
+        def before_parse(file_path) # rubocop:disable Metrics/MethodLength
+          add_info("Starting QEA parsing for: #{file_path}")
+
+          # Check file size and provide estimates
+          file_size = File.size(file_path)
+          add_info("QEA file size: #{format_file_size(file_size)}")
+
+          if file_size > 500 * 1024 * 1024 # 500MB
+            add_warning("Very large QEA file detected, " \
+                        "parsing may take significant time")
+          end
+
+          # Quick database info check
+          begin
+            quick_stats = get_quick_database_stats(file_path)
+            add_info("Database contains approximately: " \
+                     "#{format_database_stats(quick_stats)}")
+          rescue StandardError => e
+            add_warning("Could not get quick database stats: #{e.message}")
+          end
+        end
+
+        # Hook called after parsing completes
+        #
+        # @param document [Lutaml::Uml::Document] Parsed document
+        # @param file_path [String] Path to the source file
+        # @return [Lutaml::Uml::Document] Processed document
+        def after_parse(document, file_path)
+          # Add QEA-specific metadata
+          add_qea_metadata(document, file_path)
+
+          # Validate QEA-specific aspects
+          if @options[:validate_transformation]
+            validate_qea_transformation(document)
+          end
+
+          # Add comprehensive statistics
+          add_transformation_statistics(document)
+
+          document
+        end
+
+        # Get default parsing options for QEA
+        #
+        # @return [Hash] Default options hash
+        def default_options
+          super.merge(
+            include_diagrams: true,
+            validate_transformation: false,
+            load_progress_callback: true,
+            cache_database: false,
+            strict_schema_validation: false,
+          )
+        end
+
+        private
+
+        # Validate QEA file format
+        #
+        # @param file_path [String] Path to validate
+        # @raise [ParseError] if file is not valid QEA
+        def validate_qea_format!(file_path) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          # Check if it's a SQLite database (QEA files are SQLite)
+          File.open(file_path, "rb") do |file|
+            header = file.read(16)
+
+            unless header == "SQLite format 3\0"
+              add_error("File does not appear to be a SQLite database")
+              raise Parsers::ParseError.new("Invalid QEA format - " \
+                                            "not a SQLite database")
+            end
+          end
+
+          # Additional validation using QEA infrastructure
+          begin
+            Ea::Qea.connect(file_path).with_connection do |db|
+              # Check for required EA tables
+              required_tables = %w[t_object t_package t_connector t_attribute]
+              missing_tables = required_tables.reject do |table|
+                db.execute(
+                  "SELECT name FROM sqlite_master " \
+                  "WHERE type='table' AND name=?", table
+                ).any?
+              end
+
+              if missing_tables.any?
+                add_warning("Missing expected EA tables: " \
+                            "#{missing_tables.join(', ')}")
+              end
+            end
+          rescue StandardError => e
+            add_error("Failed to validate QEA database structure: #{e.message}")
+            raise Parsers::ParseError.new("QEA validation failed",
+                                          original_error: e)
+          end
+        end
+
+        # Load QEA database with progress tracking
+        #
+        # @param file_path [String] Path to QEA file
+        # @return [Ea::Qea::Database] Loaded database
+        def load_qea_database(file_path) # rubocop:disable Metrics/MethodLength
+          progress_callback = nil
+
+          if @options[:load_progress_callback]
+            progress_callback = create_progress_callback
+          end
+
+          # Load database using existing QEA infrastructure
+          if progress_callback
+            Ea::Qea.load_database(file_path, &progress_callback)
+          else
+            Ea::Qea.load_database(file_path)
+          end
+        rescue StandardError => e
+          add_error("Failed to load QEA database: #{e.message}")
+          raise Parsers::ParseError.new("QEA database loading failed",
+                                        original_error: e)
+        end
+
+        # Create progress callback for database loading
+        #
+        # @return [Proc] Progress callback procedure
+        def create_progress_callback
+          proc do |table_name, current, total|
+            percentage = (current.to_f / total * 100).round(1)
+            add_info("Loading #{table_name}: #{current}/#{total} " \
+                     "(#{percentage}%)")
+
+            # Check if we should fail fast on too many errors
+            if should_fail_fast? && has_errors?
+              raise Parsers::ParseError.new("Failing fast due to errors " \
+                                            "during loading")
+            end
+          end
+        end
+
+        # Transform QEA database to UML document
+        #
+        # @param database [Ea::Qea::Database] QEA database
+        # @param file_path [String] Source file path
+        # @return [Lutaml::Uml::Document] UML document
+        def transform_qea_to_uml(database, file_path) # rubocop:disable Metrics/MethodLength
+          # Prepare transformation options
+          transform_options = prepare_transformation_options(file_path)
+
+          # Use existing QEA factory for transformation
+          factory = Ea::Qea::Factory::EaToUmlFactory.new(database,
+                                                             transform_options)
+
+          # Apply custom transformers if configured
+          apply_custom_transformers(factory) if @options[:custom_transformers]
+
+          # Execute transformation
+          factory.create_document
+        rescue StandardError => e
+          add_error("Failed to transform QEA to UML: #{e.message}")
+          raise Parsers::ParseError.new("QEA transformation failed",
+                                        original_error: e)
+        end
+
+        # Prepare transformation options from parser configuration
+        #
+        # @param file_path [String] Source file path
+        # @return [Hash] Transformation options
+        def prepare_transformation_options(file_path)
+          {
+            include_diagrams: @options[:include_diagrams],
+            validate: @options[:validate_output],
+            document_name: extract_document_name(file_path),
+          }
+        end
+
+        # Extract document name from file path
+        #
+        # @param file_path [String] File path
+        # @return [String] Document name
+        def extract_document_name(file_path)
+          @options[:document_name] || File.basename(file_path, ".*")
+        end
+
+        # Apply custom transformers to factory
+        #
+        # @param factory [Ea::Qea::Factory::EaToUmlFactory]
+        # Factory to enhance
+        # @return [void]
+        def apply_custom_transformers(_factory)
+          # This is a placeholder for future custom transformer support
+          # Could allow configuration-driven transformer customization
+          add_info("Custom transformers would be applied here")
+        end
+
+        # Post-process QEA document
+        #
+        # @param document [Lutaml::Uml::Document] Document to process
+        # @param file_path [String] Source file path
+        # @return [void]
+        def post_process_qea_document(document, file_path)
+          assign_if_supported(document, :source_file=, file_path)
+          assign_if_supported(document, :source_format=, "QEA")
+          assign_if_supported(document, :database_stats=, @database_stats)
+        end
+
+        # Add QEA-specific metadata to document
+        #
+        # @param document [Lutaml::Uml::Document] Document to enhance
+        # @param file_path [String] Source file path
+        # @return [void]
+        def add_qea_metadata(document, file_path) # rubocop:disable Metrics/MethodLength
+          metadata = {
+            source_file: file_path,
+            source_format: "Enterprise Architect Database",
+            parsed_at: Time.now,
+            parser: self.class.name,
+            parser_version: "1.0",
+            database_stats: @database_stats,
+            qea_version: detect_qea_version,
+            options: @options,
+          }
+
+          assign_if_supported(document, :parsing_metadata=, metadata)
+          assign_if_supported(document, :metadata=, metadata)
+        end
+
+        # Detect QEA/EA version from database
+        #
+        # @return [String] Detected version or "unknown"
+        def detect_qea_version
+          return "unknown" unless @qea_database
+
+          # This is a simplified version detection
+          # In practice, you might check specific tables or metadata
+          "EA Database"
+        end
+
+        # Validate QEA transformation quality
+        #
+        # @param document [Lutaml::Uml::Document] Document to validate
+        # @return [void]
+        def validate_qea_transformation(document) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          # Compare document stats with database stats
+          if @database_stats
+            doc_packages = document.packages&.size || 0
+            db_packages = @database_stats["packages"] || 0
+
+            if doc_packages < db_packages
+              add_warning("Document has fewer packages (#{doc_packages}) " \
+                          "than database (#{db_packages})")
+            end
+
+            doc_classes = document.classes&.size || 0
+            db_objects = @database_stats["objects"] || 0
+
+            if doc_classes < db_objects * 0.8 # Allow some variance
+              add_warning("Document classes (#{doc_classes}) significantly " \
+                          "fewer than database objects (#{db_objects})")
+            end
+          end
+        end
+
+        # Add comprehensive transformation statistics
+        #
+        # @param document [Lutaml::Uml::Document] Document to analyze
+        # @return [void]
+        def add_transformation_statistics(document) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          doc_stats = {
+            packages: document.packages&.size || 0,
+            classes: document.classes&.size || 0,
+            data_types: document.data_types&.size || 0,
+            enumerations: document.enums&.size || 0,
+            associations: document.associations&.size || 0,
+            diagrams: document.diagrams&.size || 0,
+          }
+
+          comparison = compare_stats_with_database(doc_stats)
+
+          add_info("QEA transformation completed: " \
+                   "#{format_statistics(doc_stats)}")
+          if comparison.any?
+            add_info("Database comparison: #{comparison.join(', ')}")
+          end
+        end
+
+        # Compare document statistics with database statistics
+        #
+        # @param doc_stats [Hash] Document statistics
+        # @return [Array<String>] Comparison notes
+        def compare_stats_with_database(doc_stats) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return [] unless @database_stats
+
+          comparisons = []
+
+          if @database_stats["packages"]
+            ratio = doc_stats[:packages].to_f / @database_stats["packages"]
+            comparisons << "packages #{(ratio * 100).round(1)}%"
+          end
+
+          if @database_stats["objects"]
+            ratio = doc_stats[:classes].to_f / @database_stats["objects"]
+            comparisons << "classes #{(ratio * 100).round(1)}%"
+          end
+
+          comparisons
+        end
+
+        # Get quick database statistics without full loading
+        #
+        # @param file_path [String] Path to QEA file
+        # @return [Hash] Quick statistics
+        def get_quick_database_stats(file_path)
+          Ea::Qea.database_info(file_path)
+        end
+
+        # Format database statistics for display
+        #
+        # @param stats [Hash] Statistics hash
+        # @return [String] Formatted string
+        def format_database_stats(stats)
+          return "unknown structure" if stats.empty?
+
+          parts = []
+          parts << "#{stats['objects']} objects" if stats["objects"]
+          parts << "#{stats['packages']} packages" if stats["packages"]
+          parts << "#{stats['connectors']} connectors" if stats["connectors"]
+
+          parts.join(", ")
+        end
+
+      end
+    end
+  end
+end

data/lib/ea/transformations/parsers/xmi_parser.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+
+module Ea
+  module Transformations
+    module Parsers
+      # XMI Parser implements the BaseParser interface for XML Metadata
+      # Interchange files.
+      #
+      # Delegates to Ea::Xmi::Parser for actual parsing.
+      class XmiParser < BaseParser
+        # Get parser format name
+        #
+        # @return [String] Human-readable format name
+        def format_name
+          "XML Metadata Interchange (XMI)"
+        end
+
+        # Get list of supported file extensions
+        #
+        # @return [Array<String>] List of extensions
+        def supported_extensions
+          [".xmi", ".xml"]
+        end
+
+        def content_patterns
+          [/xmi:version/]
+        end
+
+        def priority
+          80
+        end
+
+        protected
+
+        # Core parsing implementation for XMI files
+        #
+        # @param file_path [String] Path to the XMI file
+        # @return [Lutaml::Uml::Document] Parsed UML document
+        def parse_internal(file_path)
+          # Validate XMI file format
+          validate_xmi_format!(file_path)
+
+          # Use Ea::Xmi::Parser for XMI parsing
+          document = Ea::Xmi::Parser.parse(File.new(file_path))
+
+          if document.nil?
+            add_error("No document found in XMI file")
+            raise Parsers::ParseError.new("Empty XMI file or parsing failed")
+          end
+
+          # Post-process document if needed
+          post_process_xmi_document(document, file_path)
+
+          document
+        end
+
+        # Hook called before parsing starts
+        #
+        # @param file_path [String] Path to the file being parsed
+        # @return [void]
+        def before_parse(file_path)
+          add_info("Starting XMI parsing for: #{file_path}")
+
+          # Check file size and warn if very large
+          file_size = File.size(file_path)
+          if file_size > 100 * 1024 * 1024 # 100MB
+            add_warning("Large XMI file detected " \
+                        "(#{format_file_size(file_size)}), " \
+                        "parsing may take time")
+          end
+        end
+
+        # Hook called after parsing completes
+        #
+        # @param document [Lutaml::Uml::Document] Parsed document
+        # @param file_path [String] Path to the source file
+        # @return [Lutaml::Uml::Document] Processed document
+        def after_parse(document, file_path)
+          # Add metadata about the parsing process
+          add_parsing_metadata(document, file_path)
+
+          # Validate references if requested
+          validate_references(document) if @options[:resolve_references]
+
+          # Count elements and add statistics
+          add_parsing_statistics(document)
+
+          document
+        end
+
+        # Get default parsing options for XMI
+        #
+        # @return [Hash] Default options hash
+        def default_options
+          super.merge(
+            validate_xml: true,
+            resolve_references: true,
+            preserve_namespaces: true,
+            include_documentation: true,
+          )
+        end
+
+        private
+
+        # Validate XMI file format
+        #
+        # @param file_path [String] Path to validate
+        # @raise [ParseError] if file is not valid XMI
+        def validate_xmi_format!(file_path) # rubocop:disable Metrics/MethodLength
+          # Quick validation by reading first few lines
+          File.open(file_path, "r") do |file|
+            header = file.read(1024)
+
+            unless header.include?("<?xml")
+              add_error("File does not appear to be an XML file")
+              raise Parsers::ParseError.new("Invalid XML format")
+            end
+
+            # Check for XMI-specific elements
+            unless header.include?("xmi:") || header.include?("uml:")
+              add_warning("File may not be a valid XMI file " \
+                          "(no XMI namespace found)")
+            end
+          end
+        end
+
+        # Post-process XMI document
+        #
+        # @param document [Lutaml::Uml::Document] Document to process
+        # @param file_path [String] Source file path
+        # @return [void]
+        def post_process_xmi_document(document, file_path)
+          assign_if_supported(document, :source_file=, file_path)
+          assign_if_supported(document, :parsed_at=, Time.now)
+          normalize_package_paths(document) if @options[:normalize_paths]
+        end
+
+        # Add parsing metadata to document
+        #
+        # @param document [Lutaml::Uml::Document] Document to enhance
+        # @param file_path [String] Source file path
+        # @return [void]
+        def add_parsing_metadata(document, file_path) # rubocop:disable Metrics/MethodLength
+          metadata = {
+            source_file: file_path,
+            parsed_at: Time.now,
+            parser: self.class.name,
+            parser_version: "1.0",
+            options: @options,
+          }
+
+          assign_if_supported(document, :parsing_metadata=, metadata)
+        end
+
+        # Validate document references
+        #
+        # @param document [Lutaml::Uml::Document] Document to validate
+        # @return [void]
+        def validate_references(document)
+          # Check for unresolved references
+          unresolved_refs = find_unresolved_references(document)
+
+          if unresolved_refs.any?
+            add_warning("Found #{unresolved_refs.size} unresolved references")
+            unresolved_refs.each do |ref|
+              add_warning("Unresolved reference: #{ref}")
+            end
+          end
+        end
+
+        # Find unresolved references in document
+        #
+        # @param document [Lutaml::Uml::Document] Document to check
+        # @return [Array<String>] List of unresolved reference IDs
+        def find_unresolved_references(document) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          unresolved = []
+
+          # This is a simplified implementation
+          # In practice, you would traverse the document structure
+          # and check for dangling references
+
+          # Check class generalizations
+          document.classes&.each do |klass|
+            klass.generalizations&.each do |gen|
+              # Reference by ID that might be unresolved
+              if gen.general.is_a?(String) && !find_element_by_id(document,
+                                                                  gen.general)
+                unresolved << gen.general
+              end
+            end
+          end
+
+          unresolved.uniq
+        end
+
+        # Find element by ID in document
+        #
+        # @param document [Lutaml::Uml::Document] Document to search
+        # @param id [String] ID to find
+        # @return [Object, nil] Found element or nil
+        def find_element_by_id(document, id)
+          # Simplified implementation - in practice would use proper indexing
+          all_elements = []
+          all_elements.concat(document.packages || [])
+          all_elements.concat(document.classes || [])
+          all_elements.concat(document.data_types || [])
+          all_elements.concat(document.enums || [])
+
+          all_elements.find { |element| element.xmi_id == id }
+        end
+
+        # Add parsing statistics
+        #
+        # @param document [Lutaml::Uml::Document] Document to analyze
+        # @return [void]
+        def add_parsing_statistics(document) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          stats = {
+            packages: document.packages&.size || 0,
+            classes: document.classes&.size || 0,
+            data_types: document.data_types&.size || 0,
+            enumerations: document.enums&.size || 0,
+            associations: document.associations&.size || 0,
+            diagrams: document.diagrams&.size || 0,
+          }
+
+          add_info("Parsed XMI successfully: #{format_statistics(stats)}")
+        end
+
+        # Normalize package paths
+        #
+        # @param document [Lutaml::Uml::Document] Document to process
+        # @return [void]
+        def normalize_package_paths(_document)
+          # Implementation would normalize package path formats
+          # This is a placeholder for future enhancement
+          add_info("Package path normalization completed")
+        end
+
+      end
+    end
+  end
+end