ea 0.3.1 → 0.5.0

data/lib/ea/transformations/configuration.rb

@@ -1,333 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-require "yaml"
-
-module Ea
-  module Transformations
-    # Configuration service for model transformations using external YAML
-    # configuration.
-    #
-    # This class follows the Dependency Inversion Principle by allowing external
-    # configuration instead of hardcoded behavior. It uses lutaml-model for
-    # structured YAML parsing and validation.
-    #
-    # @example Load default configuration
-    #   config = Configuration.load
-    #   puts config.enabled_formats
-    #
-    # @example Load custom configuration
-    #   config = Configuration.load("my_config.yml")
-    #   parser_config = config.parser_config_for("xmi")
-    class Configuration < Lutaml::Model::Serializable
-      # Parser configuration model
-      class ParserConfig < Lutaml::Model::Serializable
-        attribute :format, :string
-        attribute :extension, :string
-        attribute :parser_class, :string
-        attribute :enabled, :boolean, default: -> { true }
-        attribute :priority, :integer, default: -> { 100 }
-        attribute :description, :string
-        attribute :options, :string, collection: true
-
-        yaml do
-          map "format", to: :format
-          map "extension", to: :extension
-          map "parser_class", to: :parser_class
-          map "enabled", to: :enabled
-          map "priority", to: :priority
-          map "description", to: :description
-          map "options", to: :options
-        end
-
-        # Check if this parser handles the given extension
-        #
-        # @param ext [String] File extension (e.g., ".xmi")
-        # @return [Boolean] true if this parser handles the extension
-        def handles_extension?(ext)
-          extension == ext.downcase
-        end
-      end
-
-      # Transformation options model
-      class TransformationOptions < Lutaml::Model::Serializable
-        attribute :validate_output, :boolean, default: -> { false }
-        attribute :include_diagrams, :boolean, default: -> { true }
-        attribute :preserve_ids, :boolean, default: -> { true }
-        attribute :resolve_references, :boolean, default: -> { true }
-        attribute :strict_mode, :boolean, default: -> { false }
-
-        yaml do
-          map "validate_output", to: :validate_output
-          map "include_diagrams", to: :include_diagrams
-          map "preserve_ids", to: :preserve_ids
-          map "resolve_references", to: :resolve_references
-          map "strict_mode", to: :strict_mode
-        end
-      end
-
-      # Format detection rules model
-      class FormatDetection < Lutaml::Model::Serializable
-        attribute :use_file_extension, :boolean, default: -> { true }
-        attribute :use_content_sniffing, :boolean, default: -> { true }
-        attribute :fallback_parser, :string
-        attribute :magic_bytes, :string, collection: true
-
-        yaml do
-          map "use_file_extension", to: :use_file_extension
-          map "use_content_sniffing", to: :use_content_sniffing
-          map "fallback_parser", to: :fallback_parser
-          map "magic_bytes", to: :magic_bytes
-        end
-      end
-
-      # Error handling configuration
-      class ErrorHandling < Lutaml::Model::Serializable
-        attribute :strategy, :string, default: -> { "continue" }
-        attribute :log_errors, :boolean, default: -> { true }
-        attribute :max_errors, :integer, default: -> { 10 }
-        attribute :fail_fast, :boolean, default: -> { false }
-
-        yaml do
-          map "strategy", to: :strategy
-          map "log_errors", to: :log_errors
-          map "max_errors", to: :max_errors
-          map "fail_fast", to: :fail_fast
-        end
-      end
-
-      attribute :version, :string
-      attribute :description, :string
-      attribute :parsers, ParserConfig, collection: true
-      attribute :transformation_options, TransformationOptions
-      attribute :format_detection, FormatDetection
-      attribute :error_handling, ErrorHandling
-
-      yaml do
-        map "version", to: :version
-        map "description", to: :description
-        map "parsers", to: :parsers
-        map "transformation_options", to: :transformation_options
-        map "format_detection", to: :format_detection
-        map "error_handling", to: :error_handling
-      end
-
-      class << self
-        # Load configuration from YAML file
-        #
-        # @param config_path [String, nil] Path to configuration file
-        #   Defaults to config/model_transformations.yml
-        # @return [Configuration] The loaded configuration
-        # @raise [Errno::ENOENT] if config file not found
-        # @raise [Lutaml::Model::Error] if YAML is invalid
-        def load(config_path = nil)
-          config_path ||= default_config_path
-
-          unless File.exist?(config_path)
-            # Create default configuration if none exists
-            return create_default_configuration
-          end
-
-          yaml_content = File.read(config_path)
-          from_yaml(yaml_content)
-        end
-
-        # Get default configuration file path
-        #
-        # @return [String] Path to default config file
-        def default_config_path
-          File.expand_path("../../../config/model_transformations.yml", __dir__)
-        end
-
-        # Create default configuration when no config file exists
-        #
-        # @return [Configuration] Default configuration instance
-        def create_default_configuration
-          new.tap do |config|
-            config.version = "1.0"
-            config.description = "Default Model Transformations Configuration"
-
-            # Default parsers
-            config.parsers = [
-              create_xmi_parser_config,
-              create_qea_parser_config,
-            ]
-
-            # Default options
-            config.transformation_options = TransformationOptions.new
-            config.format_detection = FormatDetection.new
-            config.error_handling = ErrorHandling.new
-          end
-        end
-
-        private
-
-        # Create default XMI parser configuration
-        #
-        # @return [ParserConfig] XMI parser configuration
-        def create_xmi_parser_config
-          ParserConfig.new.tap do |parser|
-            parser.format = "xmi"
-            parser.extension = ".xmi"
-            parser.parser_class = "Ea::Transformations::Parsers::XmiParser"
-            parser.enabled = true
-            parser.priority = 100
-            parser.description = "XML Metadata Interchange parser"
-            parser.options = ["validate_xml", "resolve_references"]
-          end
-        end
-
-        # Create default QEA parser configuration
-        #
-        # @return [ParserConfig] QEA parser configuration
-        def create_qea_parser_config
-          ParserConfig.new.tap do |parser|
-            parser.format = "qea"
-            parser.extension = ".qea"
-            parser.parser_class = "Ea::Transformations::Parsers::QeaParser"
-            parser.enabled = true
-            parser.priority = 90
-            parser.description = "Enterprise Architect database parser"
-            parser.options = ["include_diagrams", "resolve_references"]
-          end
-        end
-      end
-
-      # Get list of enabled parsers, sorted by priority
-      #
-      # @return [Array<ParserConfig>] Array of enabled parser configurations
-      def enabled_parsers
-        parsers&.select(&:enabled)&.sort_by { |p| -p.priority } || []
-      end
-
-      # Get parser configuration by format name
-      #
-      # @param format [String] The format name (e.g., "xmi", "qea")
-      # @return [ParserConfig, nil] The parser configuration or nil if not found
-      def parser_config_for(format)
-        parsers&.find { |p| p.format == format.downcase }
-      end
-
-      # Get parser configuration by file extension
-      #
-      # @param extension [String] The file extension (e.g., ".xmi", ".qea")
-      # @return [ParserConfig, nil] The parser configuration or nil if not found
-      def parser_config_for_extension(extension)
-        normalized_ext = extension.downcase
-        unless normalized_ext.start_with?(".")
-          normalized_ext = ".#{normalized_ext}"
-        end
-
-        enabled_parsers.find { |p| p.handles_extension?(normalized_ext) }
-      end
-
-      # Check if a format is enabled
-      #
-      # @param format [String] The format name
-      # @return [Boolean] true if format is enabled
-      def format_enabled?(format)
-        parser = parser_config_for(format)
-        parser&.enabled == true
-      end
-
-      # Get all enabled format names
-      #
-      # @return [Array<String>] Array of enabled format names
-      def enabled_formats
-        enabled_parsers.map(&:format)
-      end
-
-      # Get all supported file extensions
-      #
-      # @return [Array<String>] Array of supported extensions
-      def supported_extensions
-        enabled_parsers.filter_map(&:extension)
-      end
-
-      # Check if content sniffing is enabled
-      #
-      # @return [Boolean] true if content sniffing should be used
-      def content_sniffing_enabled?
-        format_detection&.use_content_sniffing == true
-      end
-
-      # Check if file extension detection is enabled
-      #
-      # @return [Boolean] true if file extension should be used for detection
-      def file_extension_detection_enabled?
-        format_detection&.use_file_extension == true
-      end
-
-      # Get fallback parser when format detection fails
-      #
-      # @return [String, nil] The fallback parser class name
-      def fallback_parser
-        format_detection&.fallback_parser
-      end
-
-      # Get transformation options with defaults
-      #
-      # @return [TransformationOptions] Transformation options
-      def transformation_options
-        @transformation_options ||= TransformationOptions.new
-      end
-
-      # Get error handling configuration with defaults
-      #
-      # @return [ErrorHandling] Error handling configuration
-      def error_handling
-        @error_handling ||= ErrorHandling.new
-      end
-
-      # Merge with another configuration (this takes precedence)
-      #
-      # @param other [Configuration] Configuration to merge with
-      # @return [Configuration] New merged configuration
-      def merge(other) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        merged = self.class.new
-
-        # Basic attributes
-        merged.version = version || other.version
-        merged.description = description || other.description
-
-        # Merge parsers (this config takes precedence)
-        merged.parsers = merge_parsers(other.parsers)
-
-        # Use this config's options, fallback to other
-        merged.transformation_options = transformation_options ||
-          other.transformation_options
-        merged.format_detection = format_detection || other.format_detection
-        merged.error_handling = error_handling || other.error_handling
-
-        merged
-      end
-
-      private
-
-      # Merge parser configurations
-      #
-      # @param other_parsers [Array<ParserConfig>] Other parsers to merge
-      # @return [Array<ParserConfig>] Merged parser list
-      def merge_parsers(other_parsers) # rubocop:disable Metrics/MethodLength
-        return parsers unless other_parsers
-        return other_parsers unless parsers
-
-        # Create a hash of this config's parsers by format
-        our_parsers = {}
-        parsers.each do |parser|
-          our_parsers[parser.format] = parser
-        end
-
-        # Add other parsers that we don't have
-        merged = parsers.dup
-        other_parsers.each do |other_parser|
-          unless our_parsers.key?(other_parser.format)
-            merged << other_parser
-          end
-        end
-
-        merged
-      end
-    end
-  end
-end

data/lib/ea/transformations/format_registry.rb

@@ -1,366 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Transformations
-    # Format Registry manages parser registration and discovery.
-    #
-    # This class implements the Registry pattern to provide a centralized
-    # location for managing format parsers. It follows the Open/Closed Principle
-    # by allowing new parsers to be registered without modifying existing code.
-    #
-    # @example Register a parser
-    #   registry = FormatRegistry.new
-    #   registry.register(".custom", MyCustomParser)
-    #
-    # @example Get parser for extension
-    #   parser_class = registry.parser_for_extension(".xmi")
-    #   parser = parser_class.new
-    class FormatRegistry
-      # @return [Hash<String, Class>] Map of extensions to parser classes
-      attr_reader :parsers
-
-      def initialize
-        @parsers = {}
-        @extensions = []
-        @default_parsers_loaded = false
-      end
-
-      # Register a parser for a file extension
-      #
-      # @param extension [String] File extension (e.g., ".xmi", ".qea")
-      # @param parser_class [Class] Parser class implementing BaseParser
-      # interface
-      # @raise [ArgumentError] if extension or parser_class is invalid
-      def register(extension, parser_class) # rubocop:disable Metrics/MethodLength
-        if extension.is_a?(Array)
-          extension.each { |ext| register(ext, parser_class) }
-          return
-        end
-
-        validate_extension!(extension)
-        validate_parser_class!(parser_class)
-
-        normalized_ext = normalize_extension(extension)
-        @parsers[normalized_ext] = parser_class
-        unless @extensions.include?(normalized_ext)
-          @extensions << normalized_ext
-        end
-      end
-
-      # Unregister a parser for a file extension
-      #
-      # @param extension [String] File extension to unregister
-      # @return [Class, nil] The unregistered parser class, or nil if not found
-      def unregister(extension)
-        normalized_ext = normalize_extension(extension)
-        @extensions.delete(normalized_ext)
-        @parsers.delete(normalized_ext)
-      end
-
-      # Auto-register a parser class based on its supported extensions
-      #
-      # @param parser_class [Class] Parser class inherited from BaseParser
-      # @return [void]
-      def auto_register_from_parser(parser_class)
-        unless parser_class.is_a?(Class) &&
-               parser_class <= Ea::Transformations::Parsers::BaseParser
-          raise ArgumentError,
-                "#{parser_class} must inherit from " \
-                "Ea::Transformations::Parsers::BaseParser"
-        end
-
-        extensions = parser_class.new.supported_extensions
-        raise ArgumentError, "Extension cannot be nil or empty" if extensions.nil? || extensions.empty?
-
-        register(extensions, parser_class)
-      end
-
-      # Get parser class for a file extension
-      #
-      # @param extension [String] File extension (e.g., ".xmi", ".qea")
-      # @return [Class, nil] Parser class, or nil if not found
-      def parser_for_extension(extension)
-        # ensure_default_parsers_loaded!
-        normalized_ext = normalize_extension(extension)
-        @parsers[normalized_ext]
-      end
-
-      # Get parser class for a file path
-      #
-      # @param file_path [String] Path to the file
-      # @return [Class, nil] Parser class, or nil if not found
-      def parser_for_file(file_path)
-        extension = File.extname(file_path)
-        parser_for_extension(extension)
-      end
-
-      # Check if an extension is supported
-      #
-      # @param extension [String] File extension to check
-      # @return [Boolean] true if extension is supported
-      def supports_extension?(extension)
-        parser_for_extension(extension) != nil
-      end
-
-      # Check if a file is supported
-      #
-      # @param file_path [String] Path to the file
-      # @return [Boolean] true if file format is supported
-      def supports_file?(file_path)
-        parser_for_file(file_path) != nil
-      end
-
-      # Get all supported extensions
-      #
-      # @return [Array<String>] List of supported file extensions
-      def supported_extensions
-        # ensure_default_parsers_loaded!
-        @parsers.keys.sort
-      end
-
-      # Get all registered parsers
-      #
-      # @return [Hash<String, Class>] Map of extensions to parser classes
-      def all_parsers
-        # ensure_default_parsers_loaded!
-        @parsers.dup
-      end
-
-      # Get parsers sorted by priority (highest first)
-      #
-      # @return [Array<Array(String, Class)>] List of [extension, parser_class]
-      def parsers_by_priority
-        @parsers.sort_by do |_ext, parser_class|
-          parser_class.new.priority
-        end.reverse
-      end
-
-      # Get all registered extensions
-      #
-      # @return [Array<String>] List of registered extensions
-      def all_extensions
-        @extensions.dup
-      end
-
-      # Get statistics about registered parsers
-      #
-      # @return [Hash] Statistics hash
-      def statistics # rubocop:disable Metrics/MethodLength
-        parsers = @parsers.values.uniq
-        total_parsers = parsers.size
-        ext_size = @extensions.size
-
-        {
-          total_parsers: total_parsers,
-          total_extensions: ext_size,
-          extensions_per_parser: (ext_size.to_f / total_parsers).round(2),
-          parser_details: parsers.map do |parser_class|
-            {
-              parser: parser_class,
-              extensions: parser_class.new.supported_extensions,
-              priority: parser_class.new.priority,
-              format_name: parser_class.new.format_name,
-            }
-          end,
-        }
-      end
-
-      def export_configuration # rubocop:disable Metrics/MethodLength
-        {
-          exported_at: Time.now,
-          parsers: @parsers.map do |parser|
-            _ext, parser_class = parser
-
-            {
-              parser_class: parser_class,
-              extensions: parser_class.new.supported_extensions,
-              priority: parser_class.new.priority,
-              format: parser_class.new.format_name,
-            }
-          end,
-        }
-      end
-
-      # Clear all registered parsers
-      #
-      # @return [void]
-      def clear
-        @extensions.clear
-        @parsers.clear
-        @default_parsers_loaded = false
-      end
-
-      # Load parsers from configuration
-      #
-      # @param configuration [Configuration] Configuration with parser
-      # definitions
-      # @return [void]
-      def load_from_configuration(configuration)
-        configuration.enabled_parsers.each do |parser_config|
-          parser_class = constantize_parser_class(parser_config.parser_class)
-          register(parser_config.extension, parser_class)
-        rescue NameError => e
-          warn "Warning: Could not load parser " \
-               "#{parser_config.parser_class}: #{e.message}"
-        end
-      end
-
-      # Create a new instance with default parsers loaded
-      #
-      # @return [FormatRegistry] New registry instance
-      def self.with_defaults
-        registry = new
-        registry.load_default_parsers
-        registry
-      end
-
-      # Load default parsers (called automatically when needed)
-      #
-      # @return [void]
-      def load_default_parsers # rubocop:disable Metrics/MethodLength
-        return if @default_parsers_loaded
-
-        # Load XMI parser if available
-        begin
-          register(".xmi", Parsers::XmiParser)
-        rescue LoadError
-          # XMI parser not available, skip
-        end
-
-        # Load QEA parser if available
-        begin
-          register(".qea", Parsers::QeaParser)
-        rescue LoadError
-          # QEA parser not available, skip
-        end
-
-        @default_parsers_loaded = true
-      end
-
-      # Detect format by file content (magic bytes/signatures)
-      #
-      # @param file_path [String] Path to the file
-      # @return [Class, nil] Parser class based on content detection
-      def detect_by_content(file_path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        # ensure_default_parsers_loaded!
-        unless File.exist?(file_path)
-          raise ArgumentError, "#{file_path} does not exist!"
-        end
-
-        # Read first few bytes to detect format
-        File.open(file_path, "rb") do |file|
-          header = file.read(1024) # Read first 1KB
-
-          return nil if header.nil? || header.empty?
-
-          # Check header match for content patterns
-          @parsers.each do |ext, parser_class|
-            parser_klass = parser_class.new
-            parser_klass.content_patterns.each do |pattern|
-              if header.match?(pattern)
-                return parser_for_extension(ext)
-              end
-            end
-          end
-
-          # Check for XML/XMI signatures
-          if header.include?("<?xml") && header.include?("xmi:")
-            ensure_default_parsers_loaded!
-            return parser_for_extension(".xmi")
-          end
-
-          # Check for SQLite database signature (QEA files)
-          if header[0..15] == "SQLite format 3\0"
-            ensure_default_parsers_loaded!
-            return parser_for_extension(".qea")
-          end
-        end
-
-        nil
-      end
-
-      # Get the best parser for a file using multiple detection methods
-      #
-      # @param file_path [String] Path to the file
-      # @param use_content_detection [Boolean] Whether to use content detection
-      # @return [Class, nil] Best parser class for the file
-      def best_parser_for_file(file_path, use_content_detection: true)
-        # First try extension-based detection
-        parser = parser_for_file(file_path)
-        return parser if parser
-
-        # Fall back to content detection if enabled
-        if use_content_detection
-          parser = detect_by_content(file_path)
-          return parser if parser
-        end
-
-        nil
-      end
-
-      private
-
-      # Ensure default parsers are loaded
-      #
-      # @return [void]
-      def ensure_default_parsers_loaded!
-        load_default_parsers unless @default_parsers_loaded
-      end
-
-      # Normalize file extension to lowercase with leading dot
-      #
-      # @param extension [String] File extension
-      # @return [String] Normalized extension
-      def normalize_extension(extension)
-        ext = extension.to_s.downcase
-        ext = ".#{ext}" unless ext.start_with?(".")
-        ext
-      end
-
-      # Validate file extension format
-      #
-      # @param extension [String] Extension to validate
-      # @raise [ArgumentError] if extension is invalid
-      def validate_extension!(extension)
-        if extension.nil? || extension.empty?
-          raise ArgumentError, "Extension cannot be nil or empty"
-        end
-
-        normalized = normalize_extension(extension)
-        unless normalized.match?(/^\.[a-z0-9]+(.[a-z0-9]+)?/)
-          raise ArgumentError, "Invalid extension format: #{extension}"
-        end
-      end
-
-      # Validate parser class implements required interface
-      #
-      # @param parser_class [Class] Parser class to validate
-      # @raise [ArgumentError] if parser class is invalid
-      def validate_parser_class!(parser_class) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-        # Check if nil
-        if parser_class.nil?
-          raise ArgumentError, "Parser class cannot be nil"
-        end
-
-        # Check if it's a class
-        unless parser_class.is_a?(Class)
-          raise ArgumentError, "Parser must be a class"
-        end
-
-        unless parser_class < Parsers::BaseParser
-          raise ArgumentError,
-                "Parser class must inherit from BaseParser"
-        end
-      end
-
-      # Convert string class name to actual class constant
-      #
-      # @param class_name [String] Fully qualified class name
-      # @return [Class] The class constant
-      # @raise [NameError] if class cannot be found
-      def constantize_parser_class(class_name)
-        Transformations.constantize(class_name) || 
-          raise(NameError, "Cannot find class: #{class_name}")
-      end    end
-  end
-end