uniword 1.2.5 → 1.3.0

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

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

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "zip"
-# LayerValidator autoloaded via lib/uniword/validation.rb
-
-module Uniword
-  module Validation
-    module Validators
-      # Validates ZIP archive integrity.
-      #
-      # Responsibility: Validate ZIP structure and contents.
-      # Single Responsibility: Only validates ZIP integrity.
-      #
-      # This is Layer 2 validation - validates the ZIP container that
-      # holds all OOXML parts.
-      #
-      # Checks:
-      # - File opens as valid ZIP
-      # - ZIP is not empty
-      # - Required entries exist
-      # - Entries are not corrupted
-      #
-      # @example Validate ZIP integrity
-      #   validator = ZipIntegrityValidator.new(config)
-      #   result = validator.validate('/path/to/document.docx')
-      #   puts result.valid? # => true
-      class ZipIntegrityValidator < LayerValidator
-        def layer_name
-          "ZIP Integrity"
-        end
-
-        def validate(path)
-          result = LayerValidationResult.new(layer_name)
-
-          begin
-            validate_zip_structure(path, result)
-          rescue Zip::Error => e
-            result.add_error(
-              "Invalid ZIP file: #{e.message}",
-              critical: true,
-            )
-          end
-
-          result
-        end
-
-        private
-
-        def validate_zip_structure(path, result)
-          Zip::File.open(path) do |zip_file|
-            # Check ZIP is not empty
-            if zip_file.entries.empty?
-              result.add_error("ZIP archive is empty", critical: true)
-              return
-            end
-
-            # Check required entries
-            validate_required_entries(zip_file, result) if check_entries?
-
-            # Check for corrupted entries
-            validate_entry_integrity(zip_file, result) if check_corruption?
-          end
-        end
-
-        def validate_required_entries(zip_file, result)
-          required_entries = [
-            "[Content_Types].xml",
-            "word/document.xml",
-          ]
-
-          required_entries.each do |entry_name|
-            next if zip_file.find_entry(entry_name)
-
-            result.add_error(
-              "Missing required file: #{entry_name}",
-              critical: true,
-            )
-          end
-        end
-
-        def validate_entry_integrity(zip_file, result)
-          zip_file.entries.each do |entry|
-            next if entry.directory?
-
-            begin
-              # Try to read first byte to check for corruption
-              entry.get_input_stream { |io| io.read(1) }
-            rescue StandardError => e
-              result.add_error(
-                "Corrupted entry: #{entry.name} (#{e.message})",
-              )
-            end
-          end
-        end
-
-        def check_entries?
-          layer_config[:check_entries] != false
-        end
-
-        def check_corruption?
-          layer_config[:check_corruption] != false
-        end
-
-        def layer_config
-          @config[:zip_integrity] || {}
-        end
-      end
-    end
-  end
-end

data/lib/uniword/validators/element_validator.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Uniword
-  module Validators
-    # Base validator for element validation
-    # Responsibility: Provide validation interface and registry for element validators
-    #
-    # This class follows the Single Responsibility Principle by separating
-    # validation logic from the element classes themselves.
-    #
-    # @example Using the validator
-    #   validator = Uniword::Validators::ElementValidator.for(Paragraph)
-    #   validator.valid?(paragraph) # => true or false
-    #
-    # @example Registering a custom validator
-    #   Uniword::Validators::ElementValidator.register(MyElement, MyValidator)
-    class ElementValidator
-      class << self
-        # Get the appropriate validator for an element class
-        #
-        # @param element_class [Class] The element class to get validator for
-        # @return [ElementValidator] An instance of the appropriate validator
-        # @raise [ArgumentError] if element_class is not a valid Element class
-        def for(element_class)
-          unless element_class.is_a?(Class) &&
-              element_class.ancestors.any? do |a|
-                a.to_s.include?("Serializable")
-              end
-            raise ArgumentError,
-                  "element_class must be a lutaml-model serializable class"
-          end
-
-          validator_class = validator_registry[element_class] || self
-          validator_class.new
-        end
-
-        # Register a validator for a specific element class
-        #
-        # @param element_class [Class] The element class
-        # @param validator_class [Class] The validator class
-        # @return [void]
-        def register(element_class, validator_class)
-          unless validator_class.ancestors.include?(ElementValidator)
-            raise ArgumentError,
-                  "validator_class must inherit from ElementValidator"
-          end
-
-          validator_registry[element_class] = validator_class
-        end
-
-        # Get the validator registry
-        #
-        # @return [Hash] The registry mapping element classes to validators
-        def validator_registry
-          @validator_registry ||= {}
-        end
-
-        # Reset the validator registry (useful for testing)
-        #
-        # @return [void]
-        def reset_registry
-          @validator_registry = {}
-        end
-      end
-
-      # Validate an element
-      #
-      # @param element [Element] The element to validate
-      # @return [Boolean] true if valid, false otherwise
-      def valid?(element)
-        return false if element.nil?
-        # v2.0: Check if element is a serializable object (has lutaml-model ancestry)
-        return false unless element.class.ancestors.any? do |a|
-          a.to_s.include?("Serializable")
-        end
-
-        true
-      end
-
-      # Get validation errors for an element
-      #
-      # @param element [Element] The element to validate
-      # @return [Array<String>] Array of error messages
-      def errors(element)
-        return ["Element is nil"] if element.nil?
-        return ["Element must be a Uniword::Element"] unless element.class.ancestors.any? { |a| a.to_s.include?("Serializable") }
-        return [] if valid?(element)
-
-        ["Element validation failed"]
-      end
-    end
-  end
-end

data/lib/uniword/validators/paragraph_validator.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-# NOTE: element_validator is already loaded by uniword.rb
-# No need to require it here to avoid circular dependencies
-
-module Uniword
-  module Validators
-    # Validator for Paragraph elements
-    # Responsibility: Validate paragraph-specific constraints
-    #
-    # A valid paragraph:
-    # - Must be a Paragraph instance
-    # - Can have zero or more runs (empty paragraphs are valid)
-    # - All runs must be valid Run instances
-    # - Properties, if present, must be valid ParagraphProperties
-    #
-    # @example Using the paragraph validator
-    #   validator = Uniword::Validators::ParagraphValidator.new
-    #   validator.valid?(paragraph) # => true or false
-    #   validator.errors(paragraph) # => ["error message", ...]
-    class ParagraphValidator < ElementValidator
-      # Validate a paragraph element
-      #
-      # @param element [Paragraph] The paragraph to validate
-      # @return [Boolean] true if valid, false otherwise
-      def valid?(element)
-        return false unless super
-        return false unless element.is_a?(Uniword::Wordprocessingml::Paragraph)
-
-        validate_runs(element) &&
-          validate_properties(element)
-      end
-
-      # Get validation errors for a paragraph
-      #
-      # @param element [Paragraph] The paragraph to validate
-      # @return [Array<String>] Array of error messages
-      def errors(element)
-        errors = []
-
-        # Check if element is nil
-        return ["Element is nil"] if element.nil?
-
-        # Check paragraph type first (more specific than base check)
-        return ["Element must be a Paragraph"] unless element.is_a?(Uniword::Wordprocessingml::Paragraph)
-
-        # Validate runs - collect all specific errors
-        errors.concat(run_errors(element))
-
-        # Validate properties - collect all specific errors
-        errors.concat(property_errors(element))
-
-        errors
-      end
-
-      private
-
-      # Validate that all runs are valid Run instances
-      #
-      # @param paragraph [Paragraph] The paragraph to validate
-      # @return [Boolean] true if all runs are valid
-      def validate_runs(paragraph)
-        return true if paragraph.runs.nil? || paragraph.runs.empty?
-
-        paragraph.runs.all?(Uniword::Wordprocessingml::Run)
-      end
-
-      # Get errors related to runs
-      #
-      # @param paragraph [Paragraph] The paragraph to validate
-      # @return [Array<String>] Array of error messages
-      def run_errors(paragraph)
-        errors = []
-
-        return errors if paragraph.runs.nil? || paragraph.runs.empty?
-
-        paragraph.runs.each_with_index do |run, index|
-          errors << "Run at index #{index} must be a Run instance" unless run.is_a?(Uniword::Wordprocessingml::Run)
-        end
-
-        errors
-      end
-
-      # Validate properties if present
-      #
-      # @param paragraph [Paragraph] The paragraph to validate
-      # @return [Boolean] true if properties are valid or nil
-      def validate_properties(paragraph)
-        return true if paragraph.properties.nil?
-
-        paragraph.properties.is_a?(Uniword::Wordprocessingml::ParagraphProperties)
-      end
-
-      # Get errors related to properties
-      #
-      # @param paragraph [Paragraph] The paragraph to validate
-      # @return [Array<String>] Array of error messages
-      def property_errors(paragraph)
-        return [] if paragraph.properties.nil?
-
-        return ["Properties must be a ParagraphProperties instance"] unless paragraph.properties.is_a?(Uniword::Wordprocessingml::ParagraphProperties)
-
-        []
-      end
-    end
-  end
-end
-
-# Register this validator when the file is loaded
-# This ensures the validator is available regardless of load order
-if defined?(Uniword::Validators::ElementValidator)
-  Uniword::Validators::ElementValidator.register(
-    Uniword::Wordprocessingml::Paragraph,
-    Uniword::Validators::ParagraphValidator,
-  )
-end