uniword 1.2.5 → 1.4.0

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

data/lib/uniword/validators/table_validator.rb

@@ -1,134 +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 Table elements
-    # Responsibility: Validate table-specific constraints
-    #
-    # A valid table:
-    # - Must be a Table instance
-    # - Can have zero or more rows (empty tables are valid)
-    # - All rows must be valid TableRow instances
-    # - All rows should have consistent column counts (warning, not error)
-    # - Properties, if present, must be valid TableProperties
-    #
-    # @example Using the table validator
-    #   validator = Uniword::Validators::TableValidator.new
-    #   validator.valid?(table) # => true or false
-    #   validator.errors(table) # => ["error message", ...]
-    class TableValidator < ElementValidator
-      # Validate a table element
-      #
-      # @param element [Table] The table to validate
-      # @return [Boolean] true if valid, false otherwise
-      def valid?(element)
-        return false unless super
-        return false unless element.is_a?(Uniword::Wordprocessingml::Table)
-
-        validate_rows(element) &&
-          validate_properties(element)
-      end
-
-      # Get validation errors for a table
-      #
-      # @param element [Table] The table 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 table type first (more specific than base check)
-        return ["Element must be a Table"] unless element.is_a?(Uniword::Wordprocessingml::Table)
-
-        # Validate rows - collect all specific errors
-        errors.concat(row_errors(element))
-
-        # Validate properties - collect all specific errors
-        errors.concat(property_errors(element))
-
-        errors
-      end
-
-      # Get validation warnings (non-critical issues)
-      #
-      # @param element [Table] The table to validate
-      # @return [Array<String>] Array of warning messages
-      def warnings(element)
-        warnings = []
-
-        return warnings unless element.is_a?(Uniword::Wordprocessingml::Table)
-        return warnings if element.rows.empty?
-
-        # Check for inconsistent column counts
-        column_counts = element.rows.map { |row| row.cells.count }.uniq
-        warnings << "Table has inconsistent column counts: #{column_counts.join(', ')}" if column_counts.size > 1
-
-        warnings
-      end
-
-      private
-
-      # Validate that all rows are valid TableRow instances
-      #
-      # @param table [Table] The table to validate
-      # @return [Boolean] true if all rows are valid
-      def validate_rows(table)
-        return true if table.rows.nil? || table.rows.empty?
-
-        table.rows.all?(Uniword::Wordprocessingml::TableRow)
-      end
-
-      # Get errors related to rows
-      #
-      # @param table [Table] The table to validate
-      # @return [Array<String>] Array of error messages
-      def row_errors(table)
-        errors = []
-
-        return errors if table.rows.nil? || table.rows.empty?
-
-        table.rows.each_with_index do |row, index|
-          errors << "Row at index #{index} must be a TableRow instance" unless row.is_a?(Uniword::Wordprocessingml::TableRow)
-        end
-
-        errors
-      end
-
-      # Validate properties if present
-      #
-      # @param table [Table] The table to validate
-      # @return [Boolean] true if properties are valid or nil
-      def validate_properties(table)
-        return true if table.properties.nil?
-
-        table.properties.is_a?(Uniword::Wordprocessingml::TableProperties)
-      end
-
-      # Get errors related to properties
-      #
-      # @param table [Table] The table to validate
-      # @return [Array<String>] Array of error messages
-      def property_errors(table)
-        return [] if table.properties.nil?
-
-        return ["Properties must be a TableProperties instance"] unless table.properties.is_a?(Uniword::Wordprocessingml::TableProperties)
-
-        []
-      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::Table,
-    Uniword::Validators::TableValidator,
-  )
-end

data/lib/uniword/validators.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Uniword
-  module Validators
-    autoload :ElementValidator, "#{__dir__}/validators/element_validator"
-    autoload :ParagraphValidator, "#{__dir__}/validators/paragraph_validator"
-    autoload :TableValidator, "#{__dir__}/validators/table_validator"
-  end
-end

data/lib/uniword/warnings/warning.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module Uniword
-  module Warnings
-    # Represents a single warning about an unsupported element or feature.
-    #
-    # Responsibility: Store information about one warning.
-    # Single Responsibility: Only represents warning data.
-    #
-    # A warning includes:
-    # - Type (unsupported_element, unsupported_attribute, etc.)
-    # - Severity (error, warning, info)
-    # - Element/attribute name
-    # - Context where it was encountered
-    # - Location in document
-    # - Suggestion for user
-    #
-    # @example Create a warning
-    #   warning = Warning.new(
-    #     type: :unsupported_element,
-    #     severity: :warning,
-    #     element: 'chart',
-    #     message: 'Unsupported element: chart',
-    #     context: 'While parsing paragraph',
-    #     suggestion: 'Chart will be preserved but not editable'
-    #   )
-    class Warning
-      # @return [Symbol] Type of warning
-      attr_reader :type
-
-      # @return [Symbol] Severity level (:error, :warning, :info)
-      attr_reader :severity
-
-      # @return [String] Element name
-      attr_reader :element
-
-      # @return [String, nil] Attribute name (for attribute warnings)
-      attr_reader :attribute
-
-      # @return [String] Warning message
-      attr_reader :message
-
-      # @return [String, nil] Context where warning occurred
-      attr_reader :context
-
-      # @return [String, nil] Location in document
-      attr_reader :location
-
-      # @return [String, nil] Suggestion for user
-      attr_reader :suggestion
-
-      # Initialize a new warning.
-      #
-      # @param attributes [Hash] Warning attributes
-      # @option attributes [Symbol] :type Warning type
-      # @option attributes [Symbol] :severity Severity level
-      # @option attributes [String] :element Element name
-      # @option attributes [String] :attribute Attribute name (optional)
-      # @option attributes [String] :message Warning message
-      # @option attributes [String] :context Context (optional)
-      # @option attributes [String] :location Location (optional)
-      # @option attributes [String] :suggestion Suggestion (optional)
-      #
-      # @example Create a warning
-      #   warning = Warning.new(
-      #     type: :unsupported_element,
-      #     severity: :error,
-      #     element: 'chart',
-      #     message: 'Unsupported element: chart'
-      #   )
-      def initialize(attributes)
-        @type = attributes[:type]
-        @severity = attributes[:severity]
-        @element = attributes[:element]
-        @attribute = attributes[:attribute]
-        @message = attributes[:message]
-        @context = attributes[:context]
-        @location = attributes[:location]
-        @suggestion = attributes[:suggestion]
-      end
-
-      # Check if this is an error-level warning.
-      #
-      # @return [Boolean] true if severity is :error
-      def error?
-        @severity == :error
-      end
-
-      # Check if this is a warning-level warning.
-      #
-      # @return [Boolean] true if severity is :warning
-      def warning?
-        @severity == :warning
-      end
-
-      # Check if this is an info-level warning.
-      #
-      # @return [Boolean] true if severity is :info
-      def info?
-        @severity == :info
-      end
-
-      # Convert to hash representation.
-      #
-      # @return [Hash] Hash representation
-      def to_h
-        {
-          type: @type,
-          severity: @severity,
-          element: @element,
-          attribute: @attribute,
-          message: @message,
-          context: @context,
-          location: @location,
-          suggestion: @suggestion,
-        }.compact
-      end
-
-      # Convert to string for display.
-      #
-      # @return [String] String representation
-      def to_s
-        severity_str = @severity.to_s.upcase
-        element_str = @attribute ? "#{@element}/@#{@attribute}" : @element
-        msg_str = @message
-        "[#{severity_str}] #{element_str}: #{msg_str}"
-      end
-    end
-  end
-end