html-proofer 4.0.0.rc2 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe365dbadbbe912ceb224355c844dbca64a07af97827b4c8ee43cf5a47c24c2f
-  data.tar.gz: 63b5df6a997e887dde145aaaabc2db988d2d28751ab91a8f9040e82676307779
+  metadata.gz: 4c86b30d36446c4e7513915f860d356094394893184e451050133d8db0051588
+  data.tar.gz: dea3274188458eec8e625e3d0e891cb383e9b533cf8f378a9348a1baf724f1e3
 SHA512:
-  metadata.gz: 5cf2b0c74896ecfc85fc98a67a6eac648de0bfe90ba0c08564031b9ee5b613237219b970e8c6f71901a300f7c14354755dc4f3878918b92c8029841795c72e01
-  data.tar.gz: b26a375b4f245b1c0edc27c5291ca86b2f738ac5a55b5fa7a64f1f148e763b5bd8961168dad9cf50bb91c4287e7bb6a2d25cdd26eac2b06b31551777984eb1ff
+  metadata.gz: 128ba50160a450747d9f7085ac6cea6231c6ec962a9d4b159df9f882682ec78396b5f2ca86264a69b1cbb0b3c28b2e96e2fb93f7e398ee60cee7d4a49b9c6b65
+  data.tar.gz: 323474cfa12ccadc4254f7dab7d035b8569fad92c4337d5946776b14a10dd30213849ed278ad9d3b314dcc20c93c5af78071b9acdaaee6635b4070a88497eb87

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,243 @@
 # 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)
+        return false unless File.directory?(file)
 
-  def unslashed_directory?(file)
-    File.directory?(file) && !file.end_with?(File::SEPARATOR)
-  end
+        !file.end_with?(File::SEPARATOR) && !follow_location?
+      end
 
-  def absolute_path?(path)
-    path.start_with?('/')
-  end
+      def follow_location?
+        @runner.options[:typhoeus] && @runner.options[:typhoeus][:followlocation]
+      end
 
-  # path is external to the file
-  def external?
-    !internal?
-  end
+      def absolute_path?(path)
+        path.start_with?("/")
+      end
 
-  def internal?
-    relative_link? || internal_absolute_link? || hash_link?
-  end
+      # path is external to the file
+      def external?
+        !internal?
+      end
 
-  def internal_absolute_link?
-    url.start_with?('/')
-  end
+      def internal?
+        relative_link? || internal_absolute_link? || hash_link?
+      end
 
-  def relative_link?
-    return false if remote?
+      def internal_absolute_link?
+        url.start_with?("/")
+      end
 
-    hash_link? || param_link? || url.start_with?('.') || url =~ /^\S/
-  end
+      def relative_link?
+        return false if remote?
 
-  def link_points_to_same_page?
-    hash_link || param_link
-  end
+        hash_link? || param_link? || url.start_with?(".") || url =~ /^\S/
+      end
 
-  def hash_link?
-    url.start_with?('#')
-  end
+      def link_points_to_same_page?
+        hash_link || param_link
+      end
 
-  def param_link?
-    url.start_with?('?')
-  end
+      def hash_link?
+        url.start_with?("#")
+      end
 
-  def sans_hash
-    @url.to_s.sub(/##{hash}/, '')
-  end
+      def param_link?
+        url.start_with?("?")
+      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})+$/
+      def sans_hash
+        @url.to_s.sub(/##{hash}/, "")
+      end
 
-    @url = Addressable::URI.parse(@url).normalize.to_s
-  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})+$/
 
-  private def swap_urls!
-    return @url if blank?(replacements = @runner.options[:swap_urls])
+        @url = Addressable::URI.parse(@url).normalize.to_s
+      end
 
-    replacements.each do |link, replace|
-      @url = @url.gsub(link, replace)
-    end
-  end
+      private def swap_urls!
+        return @url if blank?(replacements = @runner.options[:swap_urls])
 
-  private def ignores_pattern?(links_to_ignore)
-    return false unless links_to_ignore.is_a?(Array)
+        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)
 
-    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)
+        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
+
+        false
       end
     end
-
-    false
   end
 end