html-proofer 4.0.0.rc3 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c88c30b96819085add5b171ae6c2b61ed24637d4acf25a0258b19fed2e6aa6b
-  data.tar.gz: 14d8383987c15edcb2868f35e7d6a56369cadd296bf0e31d5e0ed5d3ccd0f6d3
+  metadata.gz: b6e8293984dde05cd406326b21fa93a638b0a972efdab95f59adfe606e8be538
+  data.tar.gz: b9323e2c6d7cf91a08f45a7b9ecb77b826c02b2ad2b6bf74e6951701b41c3bdb
 SHA512:
-  metadata.gz: 3b2f276abff0c540bb08fc26d6267bacefc8e1a9bf2f5e2aa1dfb3294398b9a63fbcfe906baa24b013dd9bf19052f826ce5d47bfce53572381aba2e948b8f918
-  data.tar.gz: fff8dcd929eed104ab69543f49e7cba4005165f909505d82bd857d1791545593d61aa988a2ef9d91c9887b2a2c57aab8bffeb3e474f8b01521827a6abbf8d475
+  metadata.gz: 6d962362e0abc03b2deb15da0b06f2e42857756b045db568c959263346957b628dee73b719de2ed9f24a03762e2ae97e2ff208ea8f216c6d0323bca77864d43d
+  data.tar.gz: 2bb9ca1d81e1a088344c8df0c513d2c0e96187cf23b7895def81fba4ac1820f56a0099a4dd2caa861df6ecd75afd4388e4a5b37e18308c4641300ab07f704d15

data/bin/htmlproofer

@@ -26,10 +26,11 @@ Mercenary.program(:htmlproofer) do |p|
   p.option 'disable_external', '--disable-external', 'If `true`, does not run the external link checker (default: `false`)'
   p.option 'enforce_https', '--enforce-https', 'Fails a link if it\'s not marked as `https` (default: `true`).'
   p.option 'extensions', '--extensions ext1,[ext2,...[', Array, 'A comma-separated list of Strings indicating the file extensions you would like to check (including the dot) (default: `.html`)'
+  p.option 'ignore_empty_alt', '--ignore-empty-alt', ' If `true`, ignores images with empty/missing alt tags (in other words, `<img alt>` and `<img alt="">` are valid; set this to `false` to flag those)'
   p.option 'ignore_files', '--ignore-files file1,[file2,...]', Array, 'A comma-separated list of Strings or RegExps containing file paths that are safe to ignore'
   p.option 'ignore_empty_mailto', '--ignore-empty-mailto', 'If `true`, allows `mailto:` `href`s which do not contain an email address'
-  p.option 'ignore_missing_alt', '--empty-alt-ignore', 'If `true`, ignores images with empty/missing alt tags'
-  p.option 'ignore_status_codes', '--http-status-ignore 123,[xxx, ...]', Array, 'A comma-separated list of numbers representing status codes to ignore.'
+  p.option 'ignore_missing_alt', '--ignore-missing-alt', 'If `true`, ignores images with missing alt tags'
+  p.option 'ignore_status_codes', '--ignore-status-codes 123,[xxx, ...]', Array, 'A comma-separated list of numbers representing status codes to ignore.'
   p.option 'ignore_urls', '--ignore-urls link1,[link2,...]', Array, 'A comma-separated list of Strings or RegExps containing URLs that are safe to ignore. This affects all HTML attributes, such as `alt` tags on images.'
   p.option 'log_level', '--log-level <level>', String, 'Sets the logging level, as determined by Yell. One of `:debug`, `:info`, `:warn`, `:error`, or `:fatal`. (default: `:info`)'
   p.option 'only_4xx', '--only-4xx', 'Only reports errors for links that fall within the 4xx status code range'

data/lib/html-proofer.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require_relative 'html_proofer'
+require_relative "html_proofer"

data/lib/html_proofer/attribute/url.rb

@@ -1,231 +1,237 @@
 # frozen_string_literal: true
 
-class HTMLProofer::Attribute::Url < HTMLProofer::Attribute
-  attr_reader :url
+module HTMLProofer
+  class Attribute
+    class Url < HTMLProofer::Attribute
+      attr_reader :url
 
-  REMOTE_SCHEMES = %w[http https].freeze
+      REMOTE_SCHEMES = ["http", "https"].freeze
 
-  def initialize(runner, link_attribute, base_url: nil)
-    super
+      def initialize(runner, link_attribute, base_url: nil)
+        super
 
-    if @raw_attribute.nil?
-      @url = nil
-    else
-      @url = @raw_attribute.delete("\u200b").strip
-      @url = Addressable::URI.join(base_url, @url).to_s unless blank?(base_url)
+        if @raw_attribute.nil?
+          @url = nil
+        else
+          @url = @raw_attribute.delete("\u200b").strip
+          @url = Addressable::URI.join(base_url, @url).to_s unless blank?(base_url)
 
-      swap_urls!
-      clean_url!
+          swap_urls!
+          clean_url!
 
-      # convert "//" links to "https://"
-      @url.start_with?('//') ? @url = "https:#{@url}" : @url
-    end
-  end
+          # convert "//" links to "https://"
+          @url.start_with?("//") ? @url = "https:#{@url}" : @url
+        end
+      end
 
-  def to_s
-    @url
-  end
+      def to_s
+        @url
+      end
 
-  def known_extension?
-    return true if hash_link?
+      def known_extension?
+        return true if hash_link?
 
-    ext = File.extname(path)
+        ext = File.extname(path)
 
-    # no extension means we use the assumed one
-    return @runner.options[:extensions].include?(@runner.options[:assume_extension]) if blank?(ext)
+        # no extension means we use the assumed one
+        return @runner.options[:extensions].include?(@runner.options[:assume_extension]) if blank?(ext)
 
-    @runner.options[:extensions].include?(ext)
-  end
+        @runner.options[:extensions].include?(ext)
+      end
 
-  def unknown_extension?
-    !known_extension?
-  end
+      def unknown_extension?
+        !known_extension?
+      end
 
-  def ignore?
-    return true if (/^javascript:/).match?(@url)
-    return true if ignores_pattern?(@runner.options[:ignore_urls])
-  end
+      def ignore?
+        return true if /^javascript:/.match?(@url)
+        return true if ignores_pattern?(@runner.options[:ignore_urls])
+      end
 
-  def valid?
-    !parts.nil?
-  end
+      def valid?
+        !parts.nil?
+      end
 
-  def path?
-    !parts.host.nil? && !parts.path.nil?
-  end
+      def path?
+        !parts.host.nil? && !parts.path.nil?
+      end
 
-  def parts
-    @parts ||= Addressable::URI.parse @url
-  rescue URI::Error, Addressable::URI::InvalidURIError
-    @parts = nil
-  end
+      def parts
+        @parts ||= Addressable::URI.parse(@url)
+      rescue URI::Error, Addressable::URI::InvalidURIError
+        @parts = nil
+      end
 
-  def path
-    Addressable::URI.unencode parts.path unless parts.nil?
-  end
+      def path
+        Addressable::URI.unencode(parts.path) unless parts.nil?
+      end
 
-  def hash
-    parts&.fragment
-  end
+      def hash
+        parts&.fragment
+      end
 
-  # Does the URL have a hash?
-  def hash?
-    !blank?(hash)
-  end
+      # Does the URL have a hash?
+      def hash?
+        !blank?(hash)
+      end
 
-  def scheme
-    parts&.scheme
-  end
+      def scheme
+        parts&.scheme
+      end
 
-  def remote?
-    REMOTE_SCHEMES.include?(scheme)
-  end
+      def remote?
+        REMOTE_SCHEMES.include?(scheme)
+      end
 
-  def http?
-    scheme == 'http'
-  end
+      def http?
+        scheme == "http"
+      end
 
-  def https?
-    scheme == 'https'
-  end
+      def https?
+        scheme == "https"
+      end
 
-  def non_http_remote?
-    !scheme.nil? && !remote?
-  end
+      def non_http_remote?
+        !scheme.nil? && !remote?
+      end
 
-  def host
-    parts&.host
-  end
+      def host
+        parts&.host
+      end
 
-  def domain_path
-    (host || '') + path
-  end
+      def domain_path
+        (host || "") + path
+      end
 
-  def query_values
-    parts&.query_values
-  end
+      def query_values
+        parts&.query_values
+      end
 
-  # checks if a file exists relative to the current pwd
-  def exists?
-    return true if base64?
+      # checks if a file exists relative to the current pwd
+      def exists?
+        return true if base64?
 
-    return @runner.checked_paths[absolute_path] if @runner.checked_paths.key?(absolute_path)
+        return @runner.checked_paths[absolute_path] if @runner.checked_paths.key?(absolute_path)
 
-    @runner.checked_paths[absolute_path] = File.exist?(absolute_path)
-  end
+        @runner.checked_paths[absolute_path] = File.exist?(absolute_path)
+      end
 
-  def base64?
-    /^data:image/.match?(@raw_attribute)
-  end
+      def base64?
+        /^data:image/.match?(@raw_attribute)
+      end
 
-  def absolute_path
-    path = file_path || @runner.current_path
+      def absolute_path
+        path = file_path || @runner.current_filename
 
-    File.expand_path(path, Dir.pwd)
-  end
+        File.expand_path(path, Dir.pwd)
+      end
 
-  def file_path
-    return if path.nil? || path.empty?
-
-    path_dot_ext = ''
-
-    path_dot_ext = path + @runner.options[:assume_extension] unless blank?(@runner.options[:assume_extension])
-
-    base = if absolute_path?(path) # path relative to root
-             # either overwrite with root_dir; or, if source is directory, use that; or, just get the current file's dirname
-             @runner.options[:root_dir] || (File.directory?(@runner.current_source) ? @runner.current_source : File.dirname(@runner.current_source))
-           # relative links, path is a file
-           elsif File.exist?(File.expand_path(path, @runner.current_source)) || File.exist?(File.expand_path(path_dot_ext, @runner.current_source))
-             File.dirname(@runner.current_path)
-           # relative links in nested dir, path is a file
-           elsif File.exist?(File.join(File.dirname(@runner.current_path), path)) || File.exist?(File.join(File.dirname(@runner.current_path), path_dot_ext)) # rubocop:disable Lint/DuplicateBranch
-             File.dirname(@runner.current_path)
-           # relative link, path is a directory
-           else
-             @runner.current_path
-           end
-
-    file = File.join(base, path)
-
-    if @runner.options[:assume_extension] && File.file?("#{file}#{@runner.options[:assume_extension]}")
-      file = "#{file}#{@runner.options[:assume_extension]}"
-    elsif File.directory?(file) && !unslashed_directory?(file) # implicit index support
-      file = File.join file, @runner.options[:directory_index_file]
-    end
+      def file_path
+        return if path.nil? || path.empty?
+
+        path_dot_ext = ""
+
+        path_dot_ext = path + @runner.options[:assume_extension] unless blank?(@runner.options[:assume_extension])
+
+        base = if absolute_path?(path) # path relative to root
+          # either overwrite with root_dir; or, if source is directory, use that; or, just get the current file's dirname
+          @runner.options[:root_dir] || (File.directory?(@runner.current_source) ? @runner.current_source : File.dirname(@runner.current_source))
+        # relative links, path is a file
+        elsif File.exist?(File.expand_path(path,
+          @runner.current_source)) || File.exist?(File.expand_path(path_dot_ext, @runner.current_source))
+          File.dirname(@runner.current_filename)
+        # relative links in nested dir, path is a file
+        elsif File.exist?(File.join(File.dirname(@runner.current_filename),
+          path)) || File.exist?(File.join(File.dirname(@runner.current_filename), path_dot_ext))
+          File.dirname(@runner.current_filename)
+        # relative link, path is a directory
+        else
+          @runner.current_filename
+        end
+
+        file = File.join(base, path)
+
+        if @runner.options[:assume_extension] && File.file?("#{file}#{@runner.options[:assume_extension]}")
+          file = "#{file}#{@runner.options[:assume_extension]}"
+        elsif File.directory?(file) && !unslashed_directory?(file) # implicit index support
+          file = File.join(file, @runner.options[:directory_index_file])
+        end
+
+        file
+      end
 
-    file
-  end
+      def unslashed_directory?(file)
+        File.directory?(file) && !file.end_with?(File::SEPARATOR)
+      end
 
-  def unslashed_directory?(file)
-    File.directory?(file) && !file.end_with?(File::SEPARATOR)
-  end
+      def absolute_path?(path)
+        path.start_with?("/")
+      end
 
-  def absolute_path?(path)
-    path.start_with?('/')
-  end
+      # path is external to the file
+      def external?
+        !internal?
+      end
 
-  # path is external to the file
-  def external?
-    !internal?
-  end
+      def internal?
+        relative_link? || internal_absolute_link? || hash_link?
+      end
 
-  def internal?
-    relative_link? || internal_absolute_link? || hash_link?
-  end
+      def internal_absolute_link?
+        url.start_with?("/")
+      end
 
-  def internal_absolute_link?
-    url.start_with?('/')
-  end
+      def relative_link?
+        return false if remote?
 
-  def relative_link?
-    return false if remote?
+        hash_link? || param_link? || url.start_with?(".") || url =~ /^\S/
+      end
 
-    hash_link? || param_link? || url.start_with?('.') || url =~ /^\S/
-  end
+      def link_points_to_same_page?
+        hash_link || param_link
+      end
 
-  def link_points_to_same_page?
-    hash_link || param_link
-  end
+      def hash_link?
+        url.start_with?("#")
+      end
 
-  def hash_link?
-    url.start_with?('#')
-  end
+      def param_link?
+        url.start_with?("?")
+      end
 
-  def param_link?
-    url.start_with?('?')
-  end
+      def sans_hash
+        @url.to_s.sub(/##{hash}/, "")
+      end
 
-  def sans_hash
-    @url.to_s.sub(/##{hash}/, '')
-  end
+      # catch any obvious issues, like strings in port numbers
+      private def clean_url!
+        return if @url =~ /^([!#{Regexp.last_match(0)}-;=?-\[\]_a-z~]|%[0-9a-fA-F]{2})+$/
 
-  # catch any obvious issues, like strings in port numbers
-  private def clean_url!
-    return if @url =~ /^([!#{Regexp.last_match(0)}-;=?-\[\]_a-z~]|%[0-9a-fA-F]{2})+$/
+        @url = Addressable::URI.parse(@url).normalize.to_s
+      end
 
-    @url = Addressable::URI.parse(@url).normalize.to_s
-  end
+      private def swap_urls!
+        return @url if blank?(replacements = @runner.options[:swap_urls])
 
-  private def swap_urls!
-    return @url if blank?(replacements = @runner.options[:swap_urls])
+        replacements.each do |link, replace|
+          @url = @url.gsub(link, replace)
+        end
+      end
 
-    replacements.each do |link, replace|
-      @url = @url.gsub(link, replace)
-    end
-  end
+      private def ignores_pattern?(links_to_ignore)
+        return false unless links_to_ignore.is_a?(Array)
 
-  private def ignores_pattern?(links_to_ignore)
-    return false unless links_to_ignore.is_a?(Array)
+        links_to_ignore.each do |link_to_ignore|
+          case link_to_ignore
+          when String
+            return true if link_to_ignore == @raw_attribute
+          when Regexp
+            return true if link_to_ignore&.match?(@raw_attribute)
+          end
+        end
 
-    links_to_ignore.each do |link_to_ignore|
-      case link_to_ignore
-      when String
-        return true if link_to_ignore == @raw_attribute
-      when Regexp
-        return true if link_to_ignore&.match?(@raw_attribute)
+        false
       end
     end
-
-    false
   end
 end