uniword 1.0.0

data/lib/uniword/validation/link_validator.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+# All classes autoloaded via lib/uniword/validation.rb and lib/uniword/configuration.rb
+
+module Uniword
+  module Validation
+    # Main orchestrator for link validation.
+    #
+    # Responsibility: Coordinate link validation across entire document.
+    # Single Responsibility: Link validation orchestration only.
+    #
+    # The LinkValidator:
+    # - Loads configuration from external YAML
+    # - Initializes appropriate checkers
+    # - Finds all links in document
+    # - Routes each link to appropriate checker
+    # - Aggregates results into ValidationReport
+    #
+    # Follows Open/Closed principle:
+    # - Adding new checker types requires no changes to this class
+    # - Checkers are configured externally
+    #
+    # @example Basic usage
+    #   validator = LinkValidator.new
+    #   report = validator.validate(document)
+    #   puts "Valid: #{report.valid?}"
+    #   report.export_html('report.html')
+    #
+    # @example Custom configuration
+    #   validator = LinkValidator.new(
+    #     config_file: 'custom_validation_rules.yml'
+    #   )
+    #   report = validator.validate(document)
+    class LinkValidator
+      # @return [Hash] Loaded configuration
+      attr_reader :config
+
+      # @return [Array<LinkChecker>] Registered checkers
+      attr_reader :checkers
+
+      # Initialize a new LinkValidator.
+      #
+      # @param config_file [String] Path to configuration file
+      #
+      # @example Create validator
+      #   validator = LinkValidator.new
+      #
+      # @example Custom config file
+      #   validator = LinkValidator.new(
+      #     config_file: 'config/custom_rules.yml'
+      #   )
+      def initialize(config_file: 'link_validation_rules')
+        @config = load_configuration(config_file)
+        @checkers = initialize_checkers
+      end
+
+      # Validate all links in a document.
+      #
+      # @param document [Object] The document to validate
+      # @return [ValidationReport] Validation report with all results
+      #
+      # @example Validate document
+      #   report = validator.validate(document)
+      #   puts "Found #{report.total_count} links"
+      #   puts "Failures: #{report.failure_count}"
+      def validate(document)
+        report = ValidationReport.new
+
+        # Validate hyperlinks
+        validate_hyperlinks(document, report)
+
+        # Validate bookmarks (cross-references)
+        validate_bookmarks(document, report)
+
+        # Validate footnote references
+        validate_footnotes(document, report)
+
+        report
+      end
+
+      private
+
+      # Load configuration from file.
+      #
+      # @param config_file [String] Configuration file name or path
+      # @return [Hash] Loaded configuration
+      def load_configuration(config_file)
+        if File.exist?(config_file)
+          Configuration::ConfigurationLoader.load_file(config_file)
+        else
+          Configuration::ConfigurationLoader.load(config_file)
+        end
+      rescue Configuration::ConfigurationError => e
+        # Use defaults if config file not found
+        warn "Warning: #{e.message}. Using default configuration."
+        { link_validation: default_configuration }
+      end
+
+      # Get default configuration.
+      #
+      # @return [Hash] Default configuration
+      def default_configuration
+        {
+          external_links: { enabled: true },
+          internal_bookmarks: { enabled: true },
+          file_references: { enabled: true },
+          footnote_references: { enabled: true }
+        }
+      end
+
+      # Initialize all link checkers from configuration.
+      #
+      # @return [Array<LinkChecker>] Array of checker instances
+      def initialize_checkers
+        config_root = @config[:link_validation] || @config
+
+        [
+          Checkers::ExternalLinkChecker.new(
+            config: config_root[:external_links] || {}
+          ),
+          Checkers::InternalLinkChecker.new(
+            config: config_root[:internal_bookmarks] || {}
+          ),
+          Checkers::FileReferenceChecker.new(
+            config: config_root[:file_references] || {}
+          ),
+          Checkers::FootnoteReferenceChecker.new(
+            config: config_root[:footnote_references] || {}
+          )
+        ]
+      end
+
+      # Validate hyperlinks in document.
+      #
+      # @param document [Object] The document
+      # @param report [ValidationReport] Report to add results to
+      def validate_hyperlinks(document, report)
+        links = extract_hyperlinks(document)
+
+        links.each do |link|
+          result = check_link(link, document)
+          report.add_result(result)
+        end
+      end
+
+      # Validate bookmark references in document.
+      #
+      # @param document [Object] The document
+      # @param report [ValidationReport] Report to add results to
+      def validate_bookmarks(document, report)
+        # Bookmark validation is handled through hyperlinks
+        # with anchor attributes, so this is already covered
+        # by validate_hyperlinks
+      end
+
+      # Validate footnote references in document.
+      #
+      # @param document [Object] The document
+      # @param report [ValidationReport] Report to add results to
+      def validate_footnotes(document, report)
+        footnote_refs = extract_footnote_references(document)
+
+        footnote_refs.each do |ref|
+          result = check_link(ref, document)
+          report.add_result(result)
+        end
+      end
+
+      # Check a single link using appropriate checker.
+      #
+      # @param link [Object] The link to check
+      # @param document [Object] The document (for context)
+      # @return [ValidationResult] Validation result
+      def check_link(link, document)
+        # Find appropriate checker
+        checker = @checkers.find { |c| c.can_check?(link) }
+
+        if checker
+          checker.check(link, document)
+        else
+          ValidationResult.unknown(
+            link,
+            'No checker available for this link type'
+          )
+        end
+      end
+
+      # Extract hyperlinks from document.
+      #
+      # @param document [Object] The document
+      # @return [Array] Array of hyperlinks
+      def extract_hyperlinks(document)
+        links = []
+
+        # Extract from paragraphs
+        if document.respond_to?(:paragraphs)
+          document.paragraphs.each do |para|
+            links.concat(extract_links_from_paragraph(para))
+          end
+        end
+
+        # Extract from tables
+        if document.respond_to?(:tables)
+          document.tables.each do |table|
+            links.concat(extract_links_from_table(table))
+          end
+        end
+
+        # Extract from headers/footers
+        if document.respond_to?(:headers) && document.headers
+          document.headers.each do |header|
+            links.concat(extract_links_from_section(header))
+          end
+        end
+
+        if document.respond_to?(:footers) && document.footers
+          document.footers.each do |footer|
+            links.concat(extract_links_from_section(footer))
+          end
+        end
+
+        links.uniq
+      end
+
+      # Extract links from paragraph.
+      #
+      # @param paragraph [Object] The paragraph
+      # @return [Array] Array of links
+      def extract_links_from_paragraph(para)
+        links = []
+
+        # Check paragraph runs for hyperlinks
+        if para.respond_to?(:runs)
+          para.runs.each do |run|
+            links << run if run.is_a?(Wordprocessingml::Hyperlink)
+          end
+        end
+
+        # Check for hyperlinks collection
+        links.concat(para.hyperlinks) if para.respond_to?(:hyperlinks)
+
+        links
+      end
+
+      # Extract links from table.
+      #
+      # @param table [Object] The table
+      # @return [Array] Array of links
+      def extract_links_from_table(table)
+        links = []
+
+        if table.respond_to?(:rows)
+          table.rows.each do |row|
+            next unless row.respond_to?(:cells)
+
+            row.cells.each do |cell|
+              next unless cell.respond_to?(:paragraphs)
+
+              cell.paragraphs.each do |para|
+                links.concat(extract_links_from_paragraph(para))
+              end
+            end
+          end
+        end
+
+        links
+      end
+
+      # Extract links from document section (header/footer).
+      #
+      # @param section [Object] The section
+      # @return [Array] Array of links
+      def extract_links_from_section(section)
+        links = []
+
+        if section.respond_to?(:paragraphs)
+          section.paragraphs.each do |para|
+            links.concat(extract_links_from_paragraph(para))
+          end
+        end
+
+        links
+      end
+
+      # Extract footnote references from document.
+      #
+      # @param document [Object] The document
+      # @return [Array] Array of footnote references
+      def extract_footnote_references(document)
+        refs = []
+
+        # Check if document has footnotes
+        if document.respond_to?(:footnotes)
+          footnotes = document.footnotes
+          case footnotes
+          when Hash
+            refs.concat(footnotes.values)
+          when Array
+            refs.concat(footnotes)
+          end
+        end
+
+        # Check if document has endnotes
+        if document.respond_to?(:endnotes)
+          endnotes = document.endnotes
+          case endnotes
+          when Hash
+            refs.concat(endnotes.values)
+          when Array
+            refs.concat(endnotes)
+          end
+        end
+
+        refs
+      end
+    end
+  end
+end

data/lib/uniword/validation/validation_report.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+# ValidationResult autoloaded via lib/uniword/validation.rb
+
+module Uniword
+  module Validation
+    # Aggregates and reports on validation results.
+    #
+    # Responsibility: Collect, organize, and export validation results.
+    # Single Responsibility: Only manages validation reporting.
+    #
+    # A validation report includes:
+    # - Collection of all validation results
+    # - Grouping by status and type
+    # - Summary statistics
+    # - Export capabilities (JSON, YAML, HTML)
+    #
+    # @example Create and use a report
+    #   report = ValidationReport.new
+    #   report.add_result(ValidationResult.success(link1))
+    #   report.add_result(ValidationResult.failure(link2, "Not found"))
+    #   puts "Valid: #{report.valid?}"
+    #   puts "Failures: #{report.failure_count}"
+    #   report.export_json('report.json')
+    class ValidationReport
+      # @return [Array<ValidationResult>] All validation results
+      attr_reader :results
+
+      # Initialize a new ValidationReport.
+      #
+      # @example Create a report
+      #   report = ValidationReport.new
+      def initialize
+        @results = []
+      end
+
+      # Add a validation result to the report.
+      #
+      # @param result [ValidationResult] The result to add
+      # @return [ValidationReport] Self for chaining
+      #
+      # @example Add a result
+      #   report.add_result(ValidationResult.success(link))
+      def add_result(result)
+        raise ArgumentError, 'Expected ValidationResult' unless
+          result.is_a?(ValidationResult)
+
+        @results << result
+        self
+      end
+
+      # Check if all validations passed.
+      #
+      # @return [Boolean] true if all results are successful
+      #
+      # @example
+      #   report.valid? # => false
+      def valid?
+        @results.all?(&:valid?)
+      end
+
+      # Get all successful results.
+      #
+      # @return [Array<ValidationResult>] Successful results
+      #
+      # @example
+      #   successes = report.successes
+      def successes
+        @results.select(&:valid?)
+      end
+
+      # Get all failed results.
+      #
+      # @return [Array<ValidationResult>] Failed results
+      #
+      # @example
+      #   failures = report.failures
+      def failures
+        @results.select(&:failure?)
+      end
+
+      # Get all warning results.
+      #
+      # @return [Array<ValidationResult>] Warning results
+      #
+      # @example
+      #   warnings = report.warnings
+      def warnings
+        @results.select(&:warning?)
+      end
+
+      # Get all unknown/skipped results.
+      #
+      # @return [Array<ValidationResult>] Unknown results
+      #
+      # @example
+      #   unknowns = report.unknowns
+      def unknowns
+        @results.select(&:unknown?)
+      end
+
+      # Get count of successful validations.
+      #
+      # @return [Integer] Success count
+      #
+      # @example
+      #   count = report.success_count
+      def success_count
+        successes.count
+      end
+
+      # Get count of failed validations.
+      #
+      # @return [Integer] Failure count
+      #
+      # @example
+      #   count = report.failure_count
+      def failure_count
+        failures.count
+      end
+
+      # Get count of warnings.
+      #
+      # @return [Integer] Warning count
+      #
+      # @example
+      #   count = report.warning_count
+      def warning_count
+        warnings.count
+      end
+
+      # Get count of unknown/skipped validations.
+      #
+      # @return [Integer] Unknown count
+      #
+      # @example
+      #   count = report.unknown_count
+      def unknown_count
+        unknowns.count
+      end
+
+      # Get total count of results.
+      #
+      # @return [Integer] Total count
+      #
+      # @example
+      #   total = report.total_count
+      def total_count
+        @results.count
+      end
+
+      # Group results by link type.
+      #
+      # @return [Hash{Symbol => Array<ValidationResult>}] Grouped results
+      #
+      # @example
+      #   grouped = report.group_by_type
+      #   # => { external: [...], internal: [...], ... }
+      def group_by_type
+        @results.group_by do |result|
+          classify_link_type(result.link)
+        end
+      end
+
+      # Get summary statistics.
+      #
+      # @return [Hash] Summary data
+      #
+      # @example
+      #   summary = report.summary
+      #   # => { total: 10, successes: 8, failures: 2, ... }
+      def summary
+        {
+          total: total_count,
+          successes: success_count,
+          failures: failure_count,
+          warnings: warning_count,
+          unknowns: unknown_count,
+          valid: valid?
+        }
+      end
+
+      # Export report to JSON file.
+      #
+      # @param file_path [String] Path to output file
+      # @return [void]
+      #
+      # @example
+      #   report.export_json('link_report.json')
+      def export_json(file_path)
+        File.write(file_path, to_json)
+      end
+
+      # Export report to YAML file.
+      #
+      # @param file_path [String] Path to output file
+      # @return [void]
+      #
+      # @example
+      #   report.export_yaml('link_report.yml')
+      def export_yaml(file_path)
+        File.write(file_path, to_yaml)
+      end
+
+      # Export report to HTML file.
+      #
+      # @param file_path [String] Path to output file
+      # @return [void]
+      #
+      # @example
+      #   report.export_html('link_report.html')
+      def export_html(file_path)
+        File.write(file_path, to_html)
+      end
+
+      # Convert to JSON string.
+      #
+      # @return [String] JSON representation
+      #
+      # @example
+      #   json = report.to_json
+      def to_json(*)
+        JSON.pretty_generate(to_h, *)
+      end
+
+      # Convert to YAML string.
+      #
+      # @return [String] YAML representation
+      #
+      # @example
+      #   yaml = report.to_yaml
+      def to_yaml
+        YAML.dump(to_h)
+      end
+
+      # Convert to HTML string.
+      #
+      # @return [String] HTML representation
+      #
+      # @example
+      #   html = report.to_html
+      def to_html
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>Link Validation Report</title>
+            <style>
+              body { font-family: Arial, sans-serif; margin: 20px; }
+              h1 { color: #333; }
+              .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
+              .summary-item { display: inline-block; margin-right: 20px; }
+              table { border-collapse: collapse; width: 100%; margin-top: 20px; }
+              th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+              th { background-color: #4CAF50; color: white; }
+              .success { color: green; }
+              .failure { color: red; }
+              .warning { color: orange; }
+              .unknown { color: gray; }
+            </style>
+          </head>
+          <body>
+            <h1>Link Validation Report</h1>
+            #{summary_html}
+            #{results_table_html}
+          </body>
+          </html>
+        HTML
+      end
+
+      # Convert to hash representation.
+      #
+      # @return [Hash] Hash representation
+      #
+      # @example
+      #   hash = report.to_h
+      def to_h
+        {
+          summary: summary,
+          results: @results.map(&:to_h),
+          by_type: group_by_type.transform_values do |results|
+            results.map(&:to_h)
+          end
+        }
+      end
+
+      # Convert to string for display.
+      #
+      # @return [String] String representation
+      #
+      # @example
+      #   puts report.to_s
+      def to_s
+        lines = [
+          'Link Validation Report',
+          '=' * 50,
+          "Total: #{total_count}",
+          "Successes: #{success_count}",
+          "Failures: #{failure_count}",
+          "Warnings: #{warning_count}",
+          "Unknowns: #{unknown_count}",
+          "Valid: #{valid?}",
+          ''
+        ]
+
+        if failures.any?
+          lines << 'Failed Links:'
+          failures.each do |result|
+            lines << "  - #{result}"
+          end
+        end
+
+        if warnings.any?
+          lines << ''
+          lines << 'Warnings:'
+          warnings.each do |result|
+            lines << "  - #{result}"
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      # Classify link type based on link object.
+      #
+      # @param link [Object] The link object
+      # @return [Symbol] Link type
+      def classify_link_type(link)
+        if link.respond_to?(:url) && link.url
+          :external
+        elsif link.respond_to?(:anchor) && link.anchor
+          :internal
+        elsif link.respond_to?(:id)
+          :footnote
+        elsif link.is_a?(String) && File.exist?(link)
+          :file
+        else
+          :unknown
+        end
+      end
+
+      # Generate HTML summary section.
+      #
+      # @return [String] HTML for summary
+      def summary_html
+        status_class = valid? ? 'success' : 'failure'
+        <<~HTML
+          <div class="summary">
+            <div class="summary-item"><strong>Total Links:</strong> #{total_count}</div>
+            <div class="summary-item"><strong>Successes:</strong> <span class="success">#{success_count}</span></div>
+            <div class="summary-item"><strong>Failures:</strong> <span class="failure">#{failure_count}</span></div>
+            <div class="summary-item"><strong>Warnings:</strong> <span class="warning">#{warning_count}</span></div>
+            <div class="summary-item"><strong>Status:</strong> <span class="#{status_class}">#{valid? ? 'VALID' : 'INVALID'}</span></div>
+          </div>
+        HTML
+      end
+
+      # Generate HTML results table.
+      #
+      # @return [String] HTML for results table
+      def results_table_html
+        return '<p>No results to display.</p>' if @results.empty?
+
+        rows = @results.map do |result|
+          status_class = result.status.to_s
+          <<~HTML
+            <tr>
+              <td class="#{status_class}">#{result.status.to_s.upcase}</td>
+              <td>#{escape_html(result.link_identifier)}</td>
+              <td>#{escape_html(result.message || '-')}</td>
+            </tr>
+          HTML
+        end
+
+        <<~HTML
+          <table>
+            <thead>
+              <tr>
+                <th>Status</th>
+                <th>Link</th>
+                <th>Message</th>
+              </tr>
+            </thead>
+            <tbody>
+              #{rows.join}
+            </tbody>
+          </table>
+        HTML
+      end
+
+      # Escape HTML special characters.
+      #
+      # @param text [String] Text to escape
+      # @return [String] Escaped text
+      def escape_html(text)
+        text.to_s
+            .gsub('&', '&amp;')
+            .gsub('<', '&lt;')
+            .gsub('>', '&gt;')
+            .gsub('"', '&quot;')
+            .gsub("'", '&#39;')
+      end
+    end
+  end
+end