uniword 1.2.5 → 1.4.0

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

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

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-# LayerValidator autoloaded via lib/uniword/validation.rb
-
-module Uniword
-  module Validation
-    module Validators
-      # Validates OOXML part structure (required/optional parts).
-      #
-      # Responsibility: Validate OOXML parts exist per ISO/IEC 29500.
-      # Single Responsibility: Only validates part existence.
-      #
-      # This is Layer 3 validation - validates that all required OOXML
-      # parts are present in the document package.
-      #
-      # Checks:
-      # - Required parts exist (Content Types, document, relationships)
-      # - Optional but common parts (styles, numbering)
-      #
-      # @example Validate OOXML parts
-      #   validator = OoxmlPartValidator.new(config)
-      #   result = validator.validate('/path/to/document.docx')
-      #   puts result.valid? # => true
-      class OoxmlPartValidator < LayerValidator
-        # Required parts per ISO/IEC 29500
-        REQUIRED_PARTS = {
-          "[Content_Types].xml" => "Content Types definition",
-          "word/document.xml" => "Main document content",
-          "_rels/.rels" => "Package relationships",
-        }.freeze
-
-        # Optional but commonly used parts
-        OPTIONAL_PARTS = {
-          "word/styles.xml" => "Styles definition",
-          "word/numbering.xml" => "Numbering definition",
-          "word/_rels/document.xml.rels" => "Document relationships",
-          "word/settings.xml" => "Document settings",
-          "word/fontTable.xml" => "Font table",
-          "word/theme/theme1.xml" => "Theme definition",
-        }.freeze
-
-        def layer_name
-          "OOXML Parts"
-        end
-
-        def validate(path)
-          result = LayerValidationResult.new(layer_name)
-
-          Zip::File.open(path) do |zip|
-            validate_required_parts(zip, result)
-            validate_optional_parts(zip, result) if warn_missing_optional?
-          end
-
-          result
-        rescue Zip::Error => e
-          result.add_error(
-            "Cannot open ZIP file: #{e.message}",
-            critical: true,
-          )
-          result
-        end
-
-        private
-
-        def validate_required_parts(zip, result)
-          return unless require_content_types? ||
-            require_document? ||
-            require_relationships?
-
-          REQUIRED_PARTS.each do |part_name, description|
-            next unless should_check_part?(part_name)
-
-            next if zip.find_entry(part_name)
-
-            result.add_error(
-              "Missing #{description}: #{part_name}",
-              critical: true,
-            )
-          end
-        end
-
-        def validate_optional_parts(zip, result)
-          OPTIONAL_PARTS.each do |part_name, description|
-            next if zip.find_entry(part_name)
-
-            result.add_info(
-              "Missing #{description}: #{part_name} (optional)",
-            )
-          end
-        end
-
-        def should_check_part?(part_name)
-          case part_name
-          when "[Content_Types].xml"
-            require_content_types?
-          when "word/document.xml"
-            require_document?
-          when "_rels/.rels"
-            require_relationships?
-          else
-            true
-          end
-        end
-
-        def require_content_types?
-          layer_config[:require_content_types] != false
-        end
-
-        def require_document?
-          layer_config[:require_document] != false
-        end
-
-        def require_relationships?
-          layer_config[:require_relationships] != false
-        end
-
-        def warn_missing_optional?
-          layer_config[:warn_missing_optional] != false
-        end
-
-        def layer_config
-          @config[:ooxml_parts] || {}
-        end
-      end
-    end
-  end
-end

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

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-require "nokogiri"
-# LayerValidator autoloaded via lib/uniword/validation.rb
-
-module Uniword
-  module Validation
-    module Validators
-      # Validates relationship integrity (targets exist, no broken refs).
-      #
-      # Responsibility: Validate relationship files and targets.
-      # Single Responsibility: Only validates relationships.
-      #
-      # This is Layer 5 validation - validates that all relationship
-      # files are valid and their targets exist.
-      #
-      # Checks:
-      # - Relationship files are well-formed
-      # - Relationship targets exist
-      # - Relationship types are valid
-      #
-      # @example Validate relationships
-      #   validator = RelationshipValidator.new(config)
-      #   result = validator.validate('/path/to/document.docx')
-      #   puts result.valid? # => true
-      class RelationshipValidator < LayerValidator
-        RELATIONSHIP_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships"
-
-        def layer_name
-          "Relationships"
-        end
-
-        def validate(path)
-          result = LayerValidationResult.new(layer_name)
-
-          Zip::File.open(path) do |zip|
-            validate_relationships(zip, result)
-          end
-
-          result
-        rescue Zip::Error => e
-          result.add_error(
-            "Cannot open ZIP file: #{e.message}",
-            critical: true,
-          )
-          result
-        end
-
-        private
-
-        def validate_relationships(zip, result)
-          rel_entries = zip.entries.select { |e| e.name.end_with?(".rels") }
-
-          if rel_entries.empty?
-            result.add_warning("No relationship files found")
-            return
-          end
-
-          rel_entries.each do |entry|
-            validate_relationship_file(zip, entry, result)
-          end
-        end
-
-        def validate_relationship_file(zip, entry, result)
-          xml_content = entry.get_input_stream.read
-          doc = Nokogiri::XML(xml_content)
-
-          # Get the base directory for this .rels file
-          base_dir = File.dirname(entry.name.sub("/_rels/", "/"))
-          base_dir = "" if base_dir == "."
-
-          doc.xpath("//xmlns:Relationship",
-                    "xmlns" => RELATIONSHIP_NAMESPACE).each do |rel|
-            validate_relationship(zip, rel, base_dir, result)
-          end
-        rescue Nokogiri::XML::SyntaxError => e
-          result.add_error(
-            "Malformed relationship file #{entry.name}: #{e.message}",
-          )
-        rescue StandardError => e
-          result.add_error(
-            "Failed to validate #{entry.name}: #{e.message}",
-          )
-        end
-
-        def validate_relationship(zip, rel_node, base_dir, result)
-          target = rel_node["Target"]
-          type = rel_node["Type"]
-          target_mode = rel_node["TargetMode"]
-
-          # Skip external relationships
-          return if target_mode == "External"
-
-          # Check if target exists
-          if check_targets_exist? && target && !target.start_with?("#")
-            target_path = resolve_target_path(base_dir, target)
-
-            unless zip.find_entry(target_path)
-              result.add_error(
-                "Relationship target not found: #{target_path}",
-              )
-            end
-          end
-
-          # Validate relationship type
-          return unless validate_types? && type
-
-          validate_relationship_type(type, result)
-        end
-
-        def resolve_target_path(base_dir, target)
-          # Handle absolute paths (starting with /)
-          return target[1..] if target.start_with?("/")
-
-          # Handle relative paths
-          if base_dir.empty?
-            target
-          else
-            File.join(base_dir, target)
-          end
-        end
-
-        def validate_relationship_type(type, result)
-          # Just validate it's a URI-like string
-          return if type.include?("/")
-
-          result.add_warning(
-            "Unusual relationship type: #{type}",
-          )
-        end
-
-        def check_targets_exist?
-          layer_config[:check_targets_exist] != false
-        end
-
-        def validate_types?
-          layer_config[:validate_types] != false
-        end
-
-        def layer_config
-          @config[:relationships] || {}
-        end
-      end
-    end
-  end
-end