uniword 1.0.0

data/lib/uniword/validation/document_validator.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'json'
+# All Validation classes autoloaded via lib/uniword/validation.rb and validators.rb
+# Configuration::ConfigurationLoader autoloaded via lib/uniword.rb
+
+module Uniword
+  module Validation
+    # Main document validator orchestrator.
+    #
+    # Responsibility: Orchestrate 7-layer document validation.
+    # Single Responsibility: Only coordinates validation layers.
+    #
+    # Validates Word documents at 7 layers (MECE):
+    # 1. File Structure - file exists, readable, valid extension
+    # 2. ZIP Integrity - valid archive, no corruption
+    # 3. OOXML Parts - required parts present
+    # 4. XML Schema - well-formed XML
+    # 5. Relationships - valid references
+    # 6. Content Types - consistent type declarations
+    # 7. Document Semantics - valid document structure
+    #
+    # External configuration: config/validation_rules.yml
+    #
+    # @example Basic validation
+    #   validator = DocumentValidator.new
+    #   report = validator.validate('document.docx')
+    #   puts report.valid? # => true
+    #
+    # @example Custom configuration
+    #   validator = DocumentValidator.new(
+    #     config_file: 'custom_validation.yml'
+    #   )
+    #   report = validator.validate('document.docx')
+    class DocumentValidator
+      # @return [Hash] Configuration
+      attr_reader :config
+
+      # @return [Array<LayerValidator>] Validators
+      attr_reader :validators
+
+      # Initialize document validator.
+      #
+      # @param config_file [String] Path to configuration file
+      #
+      # @example Create with default config
+      #   validator = DocumentValidator.new
+      #
+      # @example Create with custom config
+      #   validator = DocumentValidator.new(
+      #     config_file: 'config/custom_validation.yml'
+      #   )
+      def initialize(config_file: nil)
+        @config = load_config(config_file)
+        @validators = initialize_validators
+      end
+
+      # Validate a document file.
+      #
+      # Runs all enabled validators in sequence. Can fail-fast on
+      # critical errors if configured.
+      #
+      # @param path [String] Path to .docx file
+      # @return [DocumentValidationReport] Validation results
+      #
+      # @example Validate a document
+      #   report = validator.validate('document.docx')
+      #   if report.valid?
+      #     puts "Document is valid!"
+      #   else
+      #     puts "Errors: #{report.errors.count}"
+      #   end
+      def validate(path)
+        report = DocumentValidationReport.new(path)
+
+        @validators.each do |validator|
+          next unless validator.enabled?
+
+          result = validator.validate(path)
+          report.add_layer_result(validator.layer_name, result)
+
+          # Fail fast if critical failure and configured to do so
+          break if result.critical_failures? && fail_fast?
+        end
+
+        report
+      end
+
+      # Quick validity check (boolean).
+      #
+      # @param path [String] Path to .docx file
+      # @return [Boolean] true if document is valid
+      #
+      # @example Quick check
+      #   if validator.valid?('document.docx')
+      #     # Process document
+      #   end
+      def valid?(path)
+        validate(path).valid?
+      end
+
+      private
+
+      def load_config(config_file)
+        if config_file
+          Configuration::ConfigurationLoader.load_file(config_file)
+        else
+          # Try to load default config
+          default_path = File.join(
+            Configuration::ConfigurationLoader::CONFIG_DIR,
+            'validation_rules.yml'
+          )
+
+          if File.exist?(default_path)
+            Configuration::ConfigurationLoader.load('validation_rules')
+          else
+            # Use empty config with defaults
+            { document_validation: { fail_fast: true } }
+          end
+        end
+      rescue Configuration::ConfigurationError
+        # If config fails to load, use defaults
+        { document_validation: { fail_fast: true } }
+      end
+
+      def initialize_validators
+        config_hash = @config[:document_validation] || @config
+
+        [
+          Validators::FileStructureValidator.new(config_hash),
+          Validators::ZipIntegrityValidator.new(config_hash),
+          Validators::OoxmlPartValidator.new(config_hash),
+          Validators::XmlSchemaValidator.new(config_hash),
+          Validators::RelationshipValidator.new(config_hash),
+          Validators::ContentTypeValidator.new(config_hash),
+          Validators::DocumentSemanticsValidator.new(config_hash)
+        ]
+      end
+
+      def fail_fast?
+        validation_config = @config[:document_validation] || {}
+        validation_config[:fail_fast] != false
+      end
+    end
+
+    # Validation report for document validation.
+    #
+    # Aggregates results from all validation layers.
+    class DocumentValidationReport
+      # @return [String] Path to validated file
+      attr_reader :file_path
+
+      # @return [Hash<String, LayerValidationResult>] Results by layer
+      attr_reader :layer_results
+
+      # Initialize a new report.
+      #
+      # @param file_path [String] Path to validated file
+      def initialize(file_path)
+        @file_path = file_path
+        @layer_results = {}
+      end
+
+      # Add a layer validation result.
+      #
+      # @param layer_name [String] Name of validation layer
+      # @param result [LayerValidationResult] Validation result
+      # @return [void]
+      def add_layer_result(layer_name, result)
+        @layer_results[layer_name] = result
+      end
+
+      # Check if document is valid overall.
+      #
+      # @return [Boolean] true if all layers passed
+      def valid?
+        @layer_results.values.all?(&:valid?)
+      end
+
+      # Get all errors from all layers.
+      #
+      # @return [Array<Hash>] All errors with layer info
+      def errors
+        @layer_results.flat_map do |layer, result|
+          result.errors.map { |err| err.merge(layer: layer) }
+        end
+      end
+
+      # Get all warnings from all layers.
+      #
+      # @return [Array<Hash>] All warnings with layer info
+      def warnings
+        @layer_results.flat_map do |layer, result|
+          result.warnings.map { |warn| warn.merge(layer: layer) }
+        end
+      end
+
+      # Get all info messages from all layers.
+      #
+      # @return [Array<Hash>] All info messages with layer info
+      def infos
+        @layer_results.flat_map do |layer, result|
+          result.infos.map { |info| info.merge(layer: layer) }
+        end
+      end
+
+      # Check if any layer has critical failures.
+      #
+      # @return [Boolean] true if critical failures exist
+      def critical_failures?
+        @layer_results.values.any?(&:critical_failures?)
+      end
+
+      # Get summary statistics.
+      #
+      # @return [Hash] Summary data
+      def summary
+        {
+          file: @file_path,
+          valid: valid?,
+          layers_validated: @layer_results.count,
+          errors: errors.count,
+          warnings: warnings.count,
+          infos: infos.count,
+          critical: critical_failures?
+        }
+      end
+
+      # Export to JSON string.
+      #
+      # @return [String] JSON representation
+      def to_json(*_args)
+        JSON.pretty_generate(
+          summary: summary,
+          layers: @layer_results.transform_values(&:to_h)
+        )
+      end
+
+      # Convert to string for display.
+      #
+      # @return [String] String representation
+      def to_s
+        lines = [
+          "Document Validation Report: #{@file_path}",
+          '=' * 60,
+          ''
+        ]
+
+        @layer_results.each_value do |result|
+          lines << result.to_s
+        end
+
+        lines << ''
+        lines << 'Summary:'
+        lines << "  Valid: #{valid?}"
+        lines << "  Errors: #{errors.count}"
+        lines << "  Warnings: #{warnings.count}"
+        lines << "  Info: #{infos.count}"
+
+        if errors.any?
+          lines << ''
+          lines << 'Errors:'
+          errors.each do |error|
+            lines << "  [#{error[:layer]}] #{error[:message]}"
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/uniword/validation/layer_validation_result.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Validation
+    # Represents the result of validating a single layer of document structure.
+    #
+    # Responsibility: Store validation outcome for one layer (file, ZIP, XML, etc.)
+    # Single Responsibility: Only represents layer validation results.
+    #
+    # A layer validation result includes:
+    # - Layer name
+    # - Collection of errors (critical and non-critical)
+    # - Collection of warnings
+    # - Collection of info messages
+    #
+    # @example Create a result
+    #   result = LayerValidationResult.new('File Structure')
+    #   result.add_error('File does not exist', critical: true)
+    #   result.valid? # => false
+    class LayerValidationResult
+      # @return [String] Name of the validation layer
+      attr_reader :layer_name
+
+      # @return [Array<Hash>] Collection of errors
+      attr_reader :errors
+
+      # @return [Array<Hash>] Collection of warnings
+      attr_reader :warnings
+
+      # @return [Array<Hash>] Collection of info messages
+      attr_reader :infos
+
+      # Initialize a new LayerValidationResult.
+      #
+      # @param layer_name [String] Name of the validation layer
+      #
+      # @example Create a result
+      #   result = LayerValidationResult.new('ZIP Integrity')
+      def initialize(layer_name)
+        @layer_name = layer_name
+        @errors = []
+        @warnings = []
+        @infos = []
+      end
+
+      # Add an error to this layer's results.
+      #
+      # @param message [String] Error message
+      # @param critical [Boolean] Whether this is a critical error
+      # @return [LayerValidationResult] Self for method chaining
+      #
+      # @example Add a critical error
+      #   result.add_error('File is corrupted', critical: true)
+      def add_error(message, critical: false)
+        @errors << { message: message, critical: critical }
+        self
+      end
+
+      # Add a warning to this layer's results.
+      #
+      # @param message [String] Warning message
+      # @return [LayerValidationResult] Self for method chaining
+      #
+      # @example Add a warning
+      #   result.add_warning('File is very large')
+      def add_warning(message)
+        @warnings << { message: message }
+        self
+      end
+
+      # Add an info message to this layer's results.
+      #
+      # @param message [String] Info message
+      # @return [LayerValidationResult] Self for method chaining
+      #
+      # @example Add info
+      #   result.add_info('Optional part missing')
+      def add_info(message)
+        @infos << { message: message }
+        self
+      end
+
+      # Check if this layer validation passed.
+      #
+      # @return [Boolean] true if no errors
+      #
+      # @example
+      #   result.valid? # => false
+      def valid?
+        @errors.empty?
+      end
+
+      # Check if this layer has critical failures.
+      #
+      # @return [Boolean] true if any critical errors
+      #
+      # @example
+      #   result.critical_failures? # => true
+      def critical_failures?
+        @errors.any? { |error| error[:critical] }
+      end
+
+      # Get count of errors.
+      #
+      # @return [Integer] Error count
+      def error_count
+        @errors.count
+      end
+
+      # Get count of warnings.
+      #
+      # @return [Integer] Warning count
+      def warning_count
+        @warnings.count
+      end
+
+      # Get count of info messages.
+      #
+      # @return [Integer] Info count
+      def info_count
+        @infos.count
+      end
+
+      # Convert to hash representation.
+      #
+      # @return [Hash] Hash representation
+      #
+      # @example
+      #   result.to_h
+      #   # => { layer: 'File Structure', valid: false, errors: [...] }
+      def to_h
+        {
+          layer: @layer_name,
+          valid: valid?,
+          critical_failures: critical_failures?,
+          errors: @errors,
+          warnings: @warnings,
+          infos: @infos
+        }
+      end
+
+      # Convert to string for display.
+      #
+      # @return [String] String representation
+      def to_s
+        status = valid? ? 'PASS' : 'FAIL'
+        details = []
+        details << "#{error_count} error(s)" if error_count.positive?
+        details << "#{warning_count} warning(s)" if warning_count.positive?
+        details << "#{info_count} info(s)" if info_count.positive?
+
+        detail_str = details.empty? ? '' : " (#{details.join(', ')})"
+        "[#{status}] #{@layer_name}#{detail_str}"
+      end
+    end
+  end
+end

data/lib/uniword/validation/layer_validator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# LayerValidationResult autoloaded via lib/uniword/validation.rb
+
+module Uniword
+  module Validation
+    # Base class for all layer validators.
+    #
+    # Responsibility: Define the interface for layer validation.
+    # Single Responsibility: Only provides validation interface.
+    #
+    # Each layer validator validates one specific aspect of document structure:
+    # - File structure (existence, permissions, etc.)
+    # - ZIP integrity (valid archive, no corruption)
+    # - OOXML parts (required files present)
+    # - XML schema (well-formed XML)
+    # - Relationships (valid references)
+    # - Content types (consistent type declarations)
+    # - Document semantics (valid structure)
+    #
+    # @example Implement a validator
+    #   class MyValidator < LayerValidator
+    #     def layer_name
+    #       'My Layer'
+    #     end
+    #
+    #     def validate(path)
+    #       result = LayerValidationResult.new(layer_name)
+    #       # Perform validation
+    #       result.add_error('Something wrong') unless valid?
+    #       result
+    #     end
+    #   end
+    class LayerValidator
+      # @return [Hash] Configuration for this validator
+      attr_reader :config
+
+      # Initialize a layer validator.
+      #
+      # @param config [Hash] Configuration hash
+      #
+      # @example Create a validator
+      #   validator = MyValidator.new(config)
+      def initialize(config = {})
+        @config = config || {}
+      end
+
+      # Get the name of this validation layer.
+      #
+      # @return [String] Layer name
+      # @raise [NotImplementedError] Must be implemented by subclass
+      #
+      # @example
+      #   validator.layer_name # => 'File Structure'
+      def layer_name
+        raise NotImplementedError,
+              "#{self.class} must implement #layer_name"
+      end
+
+      # Validate the document at this layer.
+      #
+      # @param path [String] Path to the document file
+      # @return [LayerValidationResult] Validation result
+      # @raise [NotImplementedError] Must be implemented by subclass
+      #
+      # @example
+      #   result = validator.validate('/path/to/document.docx')
+      def validate(path)
+        raise NotImplementedError,
+              "#{self.class} must implement #validate"
+      end
+
+      # Check if this validator is enabled.
+      #
+      # @return [Boolean] true if enabled
+      #
+      # @example
+      #   validator.enabled? # => true
+      def enabled?
+        layer_config = @config[config_key]
+        return true if layer_config.nil?
+
+        layer_config[:enabled] != false
+      end
+
+      private
+
+      # Get the configuration key for this layer.
+      #
+      # Converts class name to snake_case config key.
+      # Example: FileStructureValidator -> :file_structure
+      #
+      # @return [Symbol] Configuration key
+      def config_key
+        name = self.class.name.split('::').last
+        name = name.gsub(/Validator$/, '')
+        name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+            .to_sym
+      end
+    end
+  end
+end

data/lib/uniword/validation/link_checker.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# ValidationResult autoloaded via lib/uniword/validation.rb
+
+module Uniword
+  module Validation
+    # Base class for link checkers.
+    #
+    # Responsibility: Define interface for link validation checkers.
+    # Single Responsibility: Provide checker contract only.
+    #
+    # All link checkers inherit from this class and implement:
+    # - can_check?(link): Can this checker validate this link?
+    # - check(link, document): Perform validation
+    #
+    # This follows the Strategy pattern - different checkers for different
+    # link types, all with the same interface.
+    #
+    # @example Create a custom checker
+    #   class MyChecker < LinkChecker
+    #     def can_check?(link)
+    #       link.respond_to?(:custom_field)
+    #     end
+    #
+    #     def check(link, document)
+    #       # Validation logic
+    #       ValidationResult.success(link)
+    #     end
+    #   end
+    #
+    # @abstract Subclass and override {#can_check?} and {#check}
+    class LinkChecker
+      # @return [Hash] Configuration for this checker
+      attr_reader :config
+
+      # Initialize a new LinkChecker.
+      #
+      # @param config [Hash] Configuration options
+      #
+      # @example Create a checker
+      #   checker = LinkChecker.new(config: { timeout: 10 })
+      def initialize(config: {})
+        @config = config || {}
+      end
+
+      # Check if this checker can validate the given link.
+      #
+      # @param link [Object] The link to check
+      # @return [Boolean] true if this checker can validate the link
+      #
+      # @example
+      #   checker.can_check?(hyperlink) # => true
+      #
+      # @abstract Subclasses must implement this method
+      def can_check?(link)
+        raise NotImplementedError,
+              "#{self.class}#can_check? must be implemented"
+      end
+
+      # Validate the given link.
+      #
+      # @param link [Object] The link to validate
+      # @param document [Object] The document containing the link (for context)
+      # @return [ValidationResult] The validation result
+      #
+      # @example
+      #   result = checker.check(hyperlink, document)
+      #
+      # @abstract Subclasses must implement this method
+      def check(link, document = nil)
+        raise NotImplementedError,
+              "#{self.class}#check must be implemented"
+      end
+
+      protected
+
+      # Check if checker is enabled in configuration.
+      #
+      # @return [Boolean] true if enabled
+      def enabled?
+        @config.fetch(:enabled, true)
+      end
+
+      # Get configuration value with default.
+      #
+      # @param key [Symbol] Configuration key
+      # @param default [Object] Default value
+      # @return [Object] Configuration value or default
+      def config_value(key, default = nil)
+        @config.fetch(key, default)
+      end
+    end
+  end
+end