uniword 1.2.5 → 1.3.0

data/lib/uniword/validation/document_validator.rb

@@ -1,272 +0,0 @@
-# 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/structural_validator.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Uniword
-  module Validation
-    # Validates in-memory DocumentRoot structure.
-    #
-    # Performs structural checks on the document model without requiring
-    # file access. Complements DocumentValidator (file-level 7-layer
-    # pipeline) for quick in-process validation.
-    #
-    # Follows Open/Closed: add new check methods and register them in
-    # CHECKS without modifying existing code.
-    #
-    # @example
-    #   validator = StructuralValidator.new(document)
-    #   validator.valid?          # => true/false
-    #   validator.errors          # => ["bookmarkStart id='42' has no bookmarkEnd"]
-    #   validator.warnings        # => ["Empty paragraph at index 7"]
-    class StructuralValidator
-      # Registered check methods. Each returns an array of
-      # { severity:, message: } hashes.
-      CHECKS = %i[
-        check_body_present
-        check_bookmark_pairing
-        check_bookmark_uniqueness
-        check_empty_paragraphs
-      ].freeze
-
-      attr_reader :document
-
-      def initialize(document)
-        @document = document
-      end
-
-      # @return [Boolean] true if no errors (warnings are non-fatal)
-      def valid?
-        errors.empty?
-      end
-
-      # @return [Array<String>] Error messages (severity: error)
-      def errors
-        @errors ||= issues
-          .select { |i| i[:severity] == :error }
-          .map { |i| i[:message] }
-      end
-
-      # @return [Array<String>] Warning messages (severity: warning)
-      def warnings
-        @warnings ||= issues
-          .select { |i| i[:severity] == :warning }
-          .map { |i| i[:message] }
-      end
-
-      # @return [Array<Hash>] All issues
-      def issues
-        @issues ||= CHECKS.flat_map { |check| send(check) }
-      end
-
-      private
-
-      def check_body_present
-        return [] if document.body
-
-        [{ severity: :error,
-           message: "Document body is missing" }]
-      end
-
-      def check_bookmark_pairing
-        return [] unless document.body
-
-        starts = document.body.bookmark_starts || []
-        ends = document.body.bookmark_ends || []
-        end_ids = ends.filter_map(&:id).to_set
-
-        starts.filter_map do |bs|
-          next if end_ids.include?(bs.id)
-
-          { severity: :error,
-            message: "bookmarkStart id='#{bs.id}' (name='#{bs.name}') " \
-                     "has no matching bookmarkEnd" }
-        end
-      end
-
-      def check_bookmark_uniqueness
-        return [] unless document.body
-
-        starts = document.body.bookmark_starts || []
-        seen = {}
-        starts.filter_map do |bs|
-          next unless bs.name
-          next if bs.name.to_s == "_GoBack" # Word internal bookmark
-
-          if seen[bs.name.to_s]
-            { severity: :warning,
-              message: "Duplicate bookmark name '#{bs.name}'" }
-          else
-            seen[bs.name.to_s] = true
-            nil
-          end
-        end
-      end
-
-      def check_empty_paragraphs
-        return [] unless document.body
-
-        paragraphs = document.body.paragraphs || []
-        paragraphs.each_with_index.filter_map do |para, idx|
-          next unless para.runs.nil? || para.runs.empty?
-
-          { severity: :warning,
-            message: "Empty paragraph at index #{idx}" }
-        end
-      end
-    end
-  end
-end

data/lib/uniword/validation/validators/content_type_validator.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-require "nokogiri"
-# LayerValidator autoloaded via lib/uniword/validation.rb
-
-module Uniword
-  module Validation
-    module Validators
-      # Validates content type consistency.
-      #
-      # Responsibility: Validate [Content_Types].xml declarations.
-      # Single Responsibility: Only validates content type definitions.
-      #
-      # This is Layer 6 validation - validates that content types are
-      # properly declared and consistent with actual file extensions.
-      #
-      # Checks:
-      # - [Content_Types].xml is well-formed
-      # - Extensions and overrides are consistent
-      # - Required content types are declared
-      #
-      # @example Validate content types
-      #   validator = ContentTypeValidator.new(config)
-      #   result = validator.validate('/path/to/document.docx')
-      #   puts result.valid? # => true
-      class ContentTypeValidator < LayerValidator
-        CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types"
-
-        REQUIRED_CONTENT_TYPES = [
-          "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
-          "application/vnd.openxmlformats-package.relationships+xml",
-        ].freeze
-
-        def layer_name
-          "Content Types"
-        end
-
-        def validate(path)
-          result = LayerValidationResult.new(layer_name)
-
-          Zip::File.open(path) do |zip|
-            validate_content_types(zip, result)
-          end
-
-          result
-        rescue Zip::Error => e
-          result.add_error(
-            "Cannot open ZIP file: #{e.message}",
-            critical: true,
-          )
-          result
-        end
-
-        private
-
-        def validate_content_types(zip, result)
-          entry = zip.find_entry("[Content_Types].xml")
-
-          unless entry
-            result.add_error(
-              "Missing [Content_Types].xml",
-              critical: true,
-            )
-            return
-          end
-
-          validate_content_types_file(zip, entry, result)
-        end
-
-        def validate_content_types_file(zip, entry, result)
-          xml_content = entry.get_input_stream.read
-          doc = Nokogiri::XML(xml_content)
-
-          # Check for required content types
-          validate_required_types(doc, result) if check_consistency?
-
-          # Validate extensions match actual files
-          if validate_extensions?
-            validate_extension_consistency(zip, doc,
-                                           result)
-          end
-        rescue Nokogiri::XML::SyntaxError => e
-          result.add_error(
-            "Malformed [Content_Types].xml: #{e.message}",
-            critical: true,
-          )
-        rescue StandardError => e
-          result.add_error(
-            "Failed to validate content types: #{e.message}",
-          )
-        end
-
-        def validate_required_types(doc, result)
-          declared_types = extract_declared_types(doc)
-
-          REQUIRED_CONTENT_TYPES.each do |required_type|
-            next if declared_types.include?(required_type)
-
-            result.add_warning(
-              "Required content type not declared: #{required_type}",
-            )
-          end
-        end
-
-        def extract_declared_types(doc)
-          types = []
-
-          # From Default elements
-          doc.xpath("//xmlns:Default",
-                    "xmlns" => CONTENT_TYPES_NAMESPACE).each do |default|
-            types << default["ContentType"] if default["ContentType"]
-          end
-
-          # From Override elements
-          doc.xpath("//xmlns:Override",
-                    "xmlns" => CONTENT_TYPES_NAMESPACE).each do |override|
-            types << override["ContentType"] if override["ContentType"]
-          end
-
-          types
-        end
-
-        def validate_extension_consistency(zip, doc, result)
-          # Get declared extensions
-          extensions = {}
-          doc.xpath("//xmlns:Default",
-                    "xmlns" => CONTENT_TYPES_NAMESPACE).each do |default|
-            ext = default["Extension"]
-            content_type = default["ContentType"]
-            extensions[ext] = content_type if ext && content_type
-          end
-
-          # Check if files with declared extensions exist
-          zip.entries.each do |entry|
-            next if entry.directory?
-
-            ext = File.extname(entry.name)[1..] # Remove leading dot
-            next unless ext
-
-            if extensions.key?(ext)
-              # Expected extension found
-            else
-              result.add_info(
-                "File #{entry.name} has undeclared extension: .#{ext}",
-              )
-            end
-          end
-        end
-
-        def check_consistency?
-          layer_config[:check_consistency] != false
-        end
-
-        def validate_extensions?
-          layer_config[:validate_extensions] != false
-        end
-
-        def layer_config
-          @config[:content_types] || {}
-        end
-      end
-    end
-  end
-end

data/lib/uniword/validation/validators/file_structure_validator.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-# LayerValidator autoloaded via lib/uniword/validation.rb
-
-module Uniword
-  module Validation
-    module Validators
-      # Validates file structure (existence, readability, extension, size).
-      #
-      # Responsibility: Validate file-level properties.
-      # Single Responsibility: Only validates file structure.
-      #
-      # This is Layer 1 validation - the most basic check that must pass
-      # before any other validation can occur.
-      #
-      # Checks:
-      # - File exists
-      # - File is readable
-      # - File extension is appropriate
-      # - File size is reasonable
-      #
-      # @example Validate a file
-      #   validator = FileStructureValidator.new(config)
-      #   result = validator.validate('/path/to/document.docx')
-      #   puts result.valid? # => true
-      class FileStructureValidator < LayerValidator
-        def layer_name
-          "File Structure"
-        end
-
-        def validate(path)
-          result = LayerValidationResult.new(layer_name)
-
-          # Check file exists
-          unless File.exist?(path)
-            return result.add_error("File does not exist",
-                                    critical: true)
-          end
-
-          # Check readable
-          unless File.readable?(path)
-            return result.add_error("File is not readable",
-                                    critical: true)
-          end
-
-          # Check extension
-          validate_extension(path, result) if check_extension?
-
-          # Check file size
-          validate_size(path, result) if check_size?
-
-          result
-        end
-
-        private
-
-        def check_extension?
-          layer_config[:check_extension] != false
-        end
-
-        def check_size?
-          layer_config[:check_size] != false
-        end
-
-        def layer_config
-          @config[:file_structure] || {}
-        end
-
-        def validate_extension(path, result)
-          allowed = layer_config[:allowed_extensions] || [".docx", ".doc"]
-
-          return if allowed.any? { |ext| path.end_with?(ext) }
-
-          result.add_warning(
-            "Unusual file extension (expected #{allowed.join(' or ')})",
-          )
-        end
-
-        def validate_size(path, result)
-          size = File.size(path)
-          max_size = @config[:max_file_size] || 104_857_600 # 100MB default
-
-          if size.zero?
-            result.add_error("File is empty", critical: true)
-          elsif size > max_size
-            result.add_warning(
-              "File is very large (#{format_bytes(size)})",
-            )
-          end
-        end
-
-        def format_bytes(bytes)
-          if bytes < 1024
-            "#{bytes} bytes"
-          elsif bytes < 1024 * 1024
-            "#{(bytes / 1024.0).round(1)} KB"
-          else
-            "#{(bytes / (1024.0 * 1024)).round(1)} MB"
-          end
-        end
-      end
-    end
-  end
-end