html-proofer 4.4.0 → 4.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98bde6dd5e32f42e5983fd1aaa7bf02d3359b40f2b4a8b5360a5826abf2cc674
-  data.tar.gz: 9b7d57fd18e625ab7cc91c46faceac510b05ba5290f665fb5dd333b92446b00b
+  metadata.gz: e54554dcf4b21e6724cff760438b0a116c2871922f7ae0373b9d234d8202b2af
+  data.tar.gz: 4ab71e2407af3f65381bd48fec4ef9bba19a9849265884adfa7d6a7d7dd797ac
 SHA512:
-  metadata.gz: a666be806bbb70028488b3ef89f1325d7b5faaec9f48e105220db2d2f7dd022c12dabac828949ffd2100bdc2b4e3bd4c1f9ce9df48bab17b9106d9453eb49f01
-  data.tar.gz: 8a58bb5b120ab3cf3eb0e692f3f52f4385bd5923d3a7c91e95dddd17d8b0e25d20dd207872099665ac37737afb6b4ed86d04d39bc7793c6af2abcd35390d2051
+  metadata.gz: 228448293b92c6e5e5938201278f963fc2573c28869721d90671f31e84747cde91c6cfc5059da3b8404c4de874e67c319391b270de24e1df5afcf20062bda698
+  data.tar.gz: da4e98326f717141c3c433cd9afd651987a8a091f5a07cd2cf95e0b5034e0a33214bf63cc1f85b234999b2eb6047afb926437ca4ab56d0eb8f81e5eaaa4aab2f

data/lib/html_proofer/configuration.rb

@@ -49,6 +49,8 @@ module HTMLProofer
 
     class << self
       def generate_defaults(opts)
+        validate_options(default_options, opts)
+
         options = PROOFER_DEFAULTS.merge(opts)
 
         options[:typhoeus] = HTMLProofer::Configuration::TYPHOEUS_DEFAULTS.merge(opts[:typhoeus] || {})
@@ -86,6 +88,24 @@ module HTMLProofer
           raise ArgumentError, "Option '#{option_name} did not contain valid JSON."
         end
       end
+
+      private
+
+      def default_options
+        PROOFER_DEFAULTS.merge(typhoeus: TYPHOEUS_DEFAULTS).merge(hydra: HYDRA_DEFAULTS).merge(parallel: PARALLEL_DEFAULTS)
+      end
+
+      def validate_options(defaults, options)
+        defaults.each do |key, default_value|
+          next unless options.key?(key)
+
+          value = options[key]
+          raise TypeError, "Invalid value for '#{key}': '#{value}'. Expected #{default_value.class}." unless value.is_a?(default_value.class)
+
+          # Iterate over nested hashes
+          validate_options(default_value, value) if default_value.is_a?(Hash)
+        end
+      end
     end
   end
 end

data/lib/html_proofer/url_validator/internal.rb

@@ -22,22 +22,39 @@ module HTMLProofer
       end
 
       def run_internal_link_checker(links)
+        # collect urls and metadata for hashes to be checked in the same target file
+        file_paths_hashes_to_check = {}
         to_add = []
-        links.each_pair do |link, matched_files|
+        links.each_with_index do |(link, matched_files), i|
+          matched_count_to_log = pluralize(matched_files.count, "reference", "references")
+          @logger.log(:debug, "(#{i + 1} / #{links.count}) Internal link #{link}: Checking #{matched_count_to_log}")
           matched_files.each do |metadata|
             url = HTMLProofer::Attribute::Url.new(@runner, link, base_url: metadata[:base_url])
 
             @runner.current_source = metadata[:source]
             @runner.current_filename = metadata[:filename]
 
-            unless file_exists?(url)
+            target_file_path = url.absolute_path
+            unless file_exists?(target_file_path)
               @failed_checks << Failure.new(@runner.current_filename, "Links > Internal",
                 "internally linking to #{url}, which does not exist", line: metadata[:line], status: nil, content: nil)
               to_add << [url, metadata, false]
               next
             end
 
-            unless hash_exists?(url)
+            hash_exists = hash_exists_for_url?(url)
+            if hash_exists.nil?
+              # the hash needs to be checked in the target file, we collect the url and metadata
+              unless file_paths_hashes_to_check.key?(target_file_path)
+                file_paths_hashes_to_check[target_file_path] = {}
+              end
+              unless file_paths_hashes_to_check[target_file_path].key?(url.hash)
+                file_paths_hashes_to_check[target_file_path][url.hash] = []
+              end
+              file_paths_hashes_to_check[target_file_path][url.hash] << [url, metadata]
+              next
+            end
+            unless hash_exists
               @failed_checks << Failure.new(@runner.current_filename, "Links > Internal",
                 "internally linking to #{url}; the file exists, but the hash '#{url.hash}' does not", line: metadata[:line], status: nil, content: nil)
               to_add << [url, metadata, false]
@@ -48,6 +65,24 @@ module HTMLProofer
           end
         end
 
+        # check hashes by target file
+        @logger.log(:info, "Checking internal link hashes in #{pluralize(file_paths_hashes_to_check.count, "file", "files")}")
+        file_paths_hashes_to_check.each_with_index do |(file_path, hashes_to_check), i|
+          hash_count_to_log = pluralize(hashes_to_check.count, "hash", "hashes")
+          @logger.log(:debug, "(#{i + 1} / #{file_paths_hashes_to_check.count}) Checking #{hash_count_to_log} in #{file_path}")
+          html = create_nokogiri(file_path)
+          hashes_to_check.each_pair do |href_hash, url_metadata|
+            exists = hash_exists_in_html?(href_hash, html)
+            url_metadata.each do |(url, metadata)|
+              unless exists
+                @failed_checks << Failure.new(metadata[:filename], "Links > Internal",
+                  "internally linking to #{url}; the file exists, but the hash '#{href_hash}' does not", line: metadata[:line], status: nil, content: nil)
+              end
+              to_add << [url, metadata, exists]
+            end
+          end
+        end
+
         # adding directly to the cache above results in an endless loop
         to_add.each do |(url, metadata, exists)|
           @cache.add_internal(url.to_s, metadata, exists)
@@ -56,15 +91,15 @@ module HTMLProofer
         @failed_checks
       end
 
-      private def file_exists?(url)
-        absolute_path = url.absolute_path
-        return @runner.checked_paths[url.absolute_path] if @runner.checked_paths.key?(absolute_path)
+      private def file_exists?(absolute_path)
+        return @runner.checked_paths[absolute_path] if @runner.checked_paths.key?(absolute_path)
 
-        @runner.checked_paths[url.absolute_path] = File.exist?(absolute_path)
+        @runner.checked_paths[absolute_path] = File.exist?(absolute_path)
       end
 
-      # verify the target hash
-      private def hash_exists?(url)
+      # verify the hash w/o just based on the URL, w/o looking at the target file
+      # => returns nil if the has could not be verified
+      private def hash_exists_for_url?(url)
         href_hash = url.hash
         return true if blank?(href_hash)
         return true unless @runner.options[:check_internal_hash]
@@ -76,10 +111,18 @@ module HTMLProofer
         decoded_href_hash = Addressable::URI.unescape(href_hash)
         fragment_ids = [href_hash, decoded_href_hash]
         # https://www.w3.org/TR/html5/single-page.html#scroll-to-fragid
-        fragment_ids.include?("top") || !find_fragments(fragment_ids, url).empty?
+        return true if fragment_ids.include?("top")
+
+        nil
+      end
+
+      private def hash_exists_in_html?(href_hash, html)
+        decoded_href_hash = Addressable::URI.unescape(href_hash)
+        fragment_ids = [href_hash, decoded_href_hash]
+        !find_fragments(fragment_ids, html).empty?
       end
 
-      private def find_fragments(fragment_ids, url)
+      private def find_fragments(fragment_ids, html)
         xpaths = fragment_ids.uniq.flat_map do |frag_id|
           escaped_frag_id = "'#{frag_id.split("'").join("', \"'\", '")}', ''"
           [
@@ -89,7 +132,6 @@ module HTMLProofer
         end
         xpaths << XpathFunctions.new
 
-        html = create_nokogiri(url.absolute_path)
         html.xpath(*xpaths)
       end
     end

data/lib/html_proofer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTMLProofer
-  VERSION = "4.4.0"
+  VERSION = "4.4.2"
 end

data/lib/html_proofer.rb

@@ -4,7 +4,7 @@ require "zeitwerk"
 lib_dir = File.join(File.dirname(__dir__), "lib")
 gem_loader = Zeitwerk::Loader.for_gem
 gem_loader.inflector.inflect(
-  "html_proofer" => "HTMLProofer"
+  "html_proofer" => "HTMLProofer",
 )
 gem_loader.ignore(File.join(lib_dir, "html-proofer.rb"))
 gem_loader.setup
@@ -25,7 +25,7 @@ module HTMLProofer
       raise ArgumentError unless file.is_a?(String)
       raise ArgumentError, "#{file} does not exist" unless File.exist?(file)
 
-      options[:type] = :file
+      options = prepare_options(options, :file)
       HTMLProofer::Runner.new(file, options)
     end
 
@@ -33,14 +33,14 @@ module HTMLProofer
       raise ArgumentError unless directory.is_a?(String)
       raise ArgumentError, "#{directory} does not exist" unless Dir.exist?(directory)
 
-      options[:type] = :directory
+      options = prepare_options(options, :directory)
       HTMLProofer::Runner.new([directory], options)
     end
 
     def check_directories(directories, options = {})
       raise ArgumentError unless directories.is_a?(Array)
 
-      options[:type] = :directory
+      options = prepare_options(options, :directory)
       directories.each do |directory|
         raise ArgumentError, "#{directory} does not exist" unless Dir.exist?(directory)
       end
@@ -50,9 +50,20 @@ module HTMLProofer
     def check_links(links, options = {})
       raise ArgumentError unless links.is_a?(Array)
 
-      options[:type] = :links
+      options = prepare_options(options, :links)
       HTMLProofer::Runner.new(links, options)
     end
+
+    private
+
+    def prepare_options(options, type)
+      options = {} if options.nil?
+
+      raise ArgumentError, "Options must be a Hash" unless options.is_a?(Hash)
+
+      options[:type] = type
+      options
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: html-proofer
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 4.4.2
 platform: ruby
 authors:
 - Garen Torikian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-13 00:00:00.000000000 Z
+date: 2022-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable