haml_lint 0.74.0 → 0.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50729598b076118b141b2cf9552e8ada142c34ed52e3bd3e1a398948355ebfc2
-  data.tar.gz: e03f59f848bfa5a5a2d792e4ee347aaf10c956b7d47920594e87e9f283f8cb1f
+  metadata.gz: 188328ae96f24b3a739665a5d3ccc7271a753afbe0ae63a1fbe3f33897492caa
+  data.tar.gz: 52b39c0992433545f610c7c18af3d06b224027edea3a9cdb97f71c7c1cf4f8c5
 SHA512:
-  metadata.gz: 7ce36a007738cb26bd4034a16cd00861f64db28ce0eefcb9dcef1edca25ee09d61521eed7dfa9b3b5bb558f0c379dde10fcbfdae3ecb72a3b1b3a24877db5188
-  data.tar.gz: 8601c85624f55a50dc33296ea88066eb935b7f5bc5843a2e2179204a7d2a259da9dcc95ee8543bc1b7205991f5d589e83f384d085e1884dfaa37ef8ed15fd9f2
+  metadata.gz: 31c53c1177acc7679c9f3c5b633a2b14278252f447ddea3b03c9d49e82d6e3d4587d44803e7b2b5ca677b726702c1a716cb02c848b8d2b71ed7bd402b78d8519
+  data.tar.gz: 253e971535ea2d8c38340e2e13a882fbe215cded72f5faa96b26dd88bb39024efe5b03d8334cc7692de4edbab2a7e49db9d4bb55a6a55e10319b52e3770a9ea4

data/config/default.yml

@@ -3,7 +3,7 @@
 # This is an opinionated list of which hooks are valuable to run and what their
 # out of the box settings should be.
 
-# Whether to ignore frontmatter at the beginning of HAML documents for
+# Whether to ignore frontmatter at the beginning of Haml documents for
 # frameworks such as Jekyll/Middleman
 skip_frontmatter: false
 
@@ -89,7 +89,7 @@ linters:
   RuboCop:
     enabled: true
     # Cops listed here are skipped entirely (passed to RuboCop via `--except`), both when
-    # reporting and when auto-correcting. This is the way to disable a cop only for HAML files,
+    # reporting and when auto-correcting. This is the way to disable a cop only for Haml files,
     # and the only way to disable a forced cop (see config/forced_rubocop_config.yml), since the
     # forced configuration always overrides `Enabled: false` set in your own .rubocop.yml.
     ignored_cops: []

data/config/forced_rubocop_config.yml

@@ -1,7 +1,7 @@
 # These are some configurations that are required for RuboCop because:
-# * HAML-Lint compiles ruby code with a particular format. If the rules mis-match that format,
-#   HAML-Lint would generate lints that the user cannot fix.
-# * HAML-Lint can autocorrect code only if the result matches some specific format
+# * Haml-Lint compiles ruby code with a particular format. If the rules mis-match that format,
+#   Haml-Lint would generate lints that the user cannot fix.
+# * Haml-Lint can autocorrect code only if the result matches some specific format
 #
 # So these configuration should not be overwritable by users.
 
@@ -31,17 +31,17 @@ Layout/CaseIndentation:
   IndentOneStep: false # Need to force the `false`
 
 # Need this cop so that code gets formatted similarly to Haml's indentation,
-# since HAML-Lint relies on Ruby's indentation being the same as Haml's.
+# since Haml-Lint relies on Ruby's indentation being the same as Haml's.
 Layout/ElseAlignment:
   Enabled: true
 
 # Need this cop so that code gets formatted similarly to Haml's indentation,
-# since HAML-Lint relies on Ruby's indentation being the same as Haml's.
+# since Haml-Lint relies on Ruby's indentation being the same as Haml's.
 Layout/EndAlignment:
   EnforcedStyleAlignWith: start_of_line
   Enabled: true
 
-# We generate the ruby content, this is basically useless and should be a lint in HAML-Lint
+# We generate the ruby content, this is basically useless and should be a lint in Haml-Lint
 Layout/EndOfLine:
   Enabled: false
 
@@ -90,14 +90,14 @@ Metrics/BlockNesting:
 Naming/FileName:
   Enabled: false
 
-# HAML doesn't properly support multiline blocks using { }, only using do/end.
+# Haml doesn't properly support multiline blocks using { }, only using do/end.
 # If you don't consider the { } block for indentation, things "works", but the indentation is misleading.
 # For example, this works:
 # - a = lambda {
 # - if abc
 #  - something
 # - }
-# But if you indented the 2 lines within { }, then HAML would add an extra `end` and the generated
+# But if you indented the 2 lines within { }, then Haml would add an extra `end` and the generated
 # ruby would be invalid.
 Style/BlockDelimiters:
   # So we need this cop to cleanup those cases and turn them to `end`.
@@ -106,7 +106,7 @@ Style/BlockDelimiters:
   # We don't allow the default "Can be anything" exception for lambda/proc
   <%= rubocop_version < '1.33' ? 'IgnoredMethods' : 'AllowedMethods' %>: []
 
-# We don't support correcting HAML comments
+# We don't support correcting Haml comments
 Style/CommentAnnotation:
   AutoCorrect: false
 
@@ -144,7 +144,7 @@ Style/RedundantStringEscape:
 <% end %>
 
 # In some case, this cop can cause a change in the spacing.
-# In HAML 5.2, going from (absurd example for clarity):
+# In Haml 5.2, going from (absurd example for clarity):
 #   = 'abc' rescue nil
 #   = 'def'
 # to:
@@ -161,7 +161,7 @@ Style/RescueModifier:
 
 # Cops that remove commas can be a problem when lines are split on multiple ones.
 # If we have a big array on more than one line, the removal of the comma generates
-# invalid HAML
+# invalid Haml
 Style/SymbolArray:
   Enabled: false
 
@@ -170,7 +170,7 @@ Style/UnlessElse:
   AutoCorrect: false
 
 # If an array of strings was on multiple lines, this cop will make a %w(...) on multiple lines.
-# Without the comma at the end of the first line, there the resulting HAML will be invalid, since the only
+# Without the comma at the end of the first line, there the resulting Haml will be invalid, since the only
 # case where a script can change line is after a comma.
 Style/WordArray:
   AutoCorrect: false
@@ -181,7 +181,7 @@ Layout/TrailingEmptyLines:
 
 <% if rubocop_version < '1.8.1' %>
 # There were a few bugs with this cop that got fixed in this version.
-# Before, those bugs would generate invalid Ruby code and that would make it look like HAML-lint is
+# Before, those bugs would generate invalid Ruby code and that would make it look like Haml-lint is
 # responsible, at least from the user's point of view.
 Style/StringConcatenation:
   Enabled: false

data/lib/haml_lint/document.rb

@@ -132,8 +132,8 @@ module HamlLint
     # @param original_tree [Haml::Parser::ParseNode]
     # @return [Haml::Tree::Node]
     def process_tree(original_tree)
-      # Remove the trailing empty HAML comment that the parser creates to signal
-      # the end of the HAML document
+      # Remove the trailing empty Haml comment that the parser creates to signal
+      # the end of the Haml document
       if Gem::Requirement.new('~> 4.0.0').satisfied_by?(Gem.loaded_specs['haml'].version)
         original_tree.children.pop
       end
@@ -142,7 +142,7 @@ module HamlLint
       convert_tree(original_tree)
     end
 
-    # Converts a HAML parse tree to a tree of {HamlLint::Tree::Node} objects.
+    # Converts a Haml parse tree to a tree of {HamlLint::Tree::Node} objects.
     #
     # This provides a cleaner interface with which the linters can interact with
     # the parse tree.

data/lib/haml_lint/exceptions.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Collection of exceptions that can be raised by the HAML Lint application.
+# Collection of exceptions that can be raised by the Haml Lint application.
 module HamlLint::Exceptions
   # Raised when a {Configuration} could not be loaded from a file.
   class ConfigurationError < StandardError; end
@@ -17,7 +17,7 @@ module HamlLint::Exceptions
   # Raised when an invalid file path is specified
   class InvalidFilePath < StandardError; end
 
-  # Raised when a problem occurs parsing a HAML document.
+  # Raised when a problem occurs parsing a Haml document.
   class ParseError < ::Haml::SyntaxError; end
 
   # Raised when attempting to execute `Runner` with options that would result in

data/lib/haml_lint/extensions/haml_util_unescape_interpolation_tracking.rb

@@ -14,8 +14,8 @@ module Haml::Util
     Thread.current[:haml_lint_unescape_interpolation_to_original_cache] ||= {}
   end
 
-  # As soon as a HamlLint::Document has finished processing a HAML source, this gets called to
-  # get a copy of this cache and clear up for the next HAML processing
+  # As soon as a HamlLint::Document has finished processing a Haml source, this gets called to
+  # get a copy of this cache and clear up for the next Haml processing
   def self.unescape_interpolation_to_original_cache_take_and_wipe
     value = unescape_interpolation_to_original_cache.dup
     unescape_interpolation_to_original_cache.clear

data/lib/haml_lint/haml_visitor.rb

@@ -2,7 +2,7 @@
 
 module HamlLint
   # Provides an interface which when included allows a class to visit nodes in
-  # the parse tree of a HAML document.
+  # the parse tree of a Haml document.
   module HamlVisitor
     def visit(node)
       # Keep track of whether this block was consumed by the visitor. This

data/lib/haml_lint/lint.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module HamlLint
-  # Contains information about a problem or issue with a HAML document.
+  # Contains information about a problem or issue with a Haml document.
   class Lint
     # @return [Boolean] If the error was corrected by auto-correct
     attr_reader :corrected
 
+    # @return [Boolean] If the error could be corrected by auto-correct
+    attr_reader :correctable
+
     # @return [String] file path to which the lint applies
     attr_reader :filename
 
@@ -28,13 +31,14 @@ module HamlLint
     # @param line [Fixnum]
     # @param message [String]
     # @param severity [Symbol]
-    def initialize(linter, filename, line, message, severity = :warning, corrected: false) # rubocop:disable Metrics/ParameterLists
+    def initialize(linter, filename, line, message, severity = :warning, corrected: false, correctable: false) # rubocop:disable Metrics/ParameterLists
       @linter   = linter
       @filename = filename
       @line     = line || 0
       @message  = message
       @severity = Severity.new(severity)
       @corrected = corrected
+      @correctable = correctable
     end
 
     # Return whether this lint has a severity of error.
@@ -45,7 +49,8 @@ module HamlLint
     end
 
     def inspect
-      "#{self.class.name}(corrected=#{corrected}, filename=#{filename}, line=#{line}, " \
+      "#{self.class.name}(corrected=#{corrected}, correctable=#{correctable}, " \
+        "filename=#{filename}, line=#{line}, " \
         "linter=#{linter.class.name}, message=#{message}, severity=#{severity})"
     end
   end

data/lib/haml_lint/linter/alignment_tabs.rb

@@ -3,12 +3,29 @@
 module HamlLint
   # Checks for tabs that are placed for alignment of tag content
   class Linter::AlignmentTabs < Linter
+    include LinterRegistry
+
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
     REGEX = /[^\s*]\t+/
+    # Same as +REGEX+, but captures the character preceding the alignment tabs
+    # so it can be kept while the tabs themselves are collapsed to a space.
+    CORRECTION_REGEX = /([^\s*])\t+/
 
     def visit_tag(node)
-      if REGEX.match?(node.source_code)
-        record_lint(node, 'Avoid using tabs for alignment')
-      end
+      return unless REGEX.match?(node.source_code)
+
+      record_lint(node, 'Avoid using tabs for alignment', corrected: correct(node))
+    end
+
+    private
+
+    # @return [Boolean] whether a correction was applied
+    def correct(node)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      correct_line(index, line.gsub(CORRECTION_REGEX) { "#{::Regexp.last_match(1)} " })
     end
   end
 end

data/lib/haml_lint/linter/consecutive_silent_scripts.rb

@@ -6,6 +6,9 @@ module HamlLint
   class Linter::ConsecutiveSilentScripts < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
     SILENT_SCRIPT_DETECTOR = ->(child) do
       child.type == :silent_script && child.children.empty?
     end
@@ -18,12 +21,21 @@ module HamlLint
         SILENT_SCRIPT_DETECTOR,
         config['max_consecutive'] + 1,
       ) do |group|
+        reported_nodes.concat(group)
         record_lint(group.first,
                     "#{group.count} consecutive Ruby scripts can be merged " \
-                    'into a single `:ruby` filter')
+                    'into a single `:ruby` filter',
+                    corrected: collect_merge(group))
       end
     end
 
+    def after_visit_root(_node)
+      super
+      return if merges.empty?
+
+      apply_autocorrect(merged_source)
+    end
+
     private
 
     def possible_group(node)
@@ -37,5 +49,60 @@ module HamlLint
     def reported_nodes
       @reported_nodes ||= []
     end
+
+    def reset_autocorrect_state
+      super
+      @merges = []
+    end
+
+    # Queues a group of consecutive silent scripts to be replaced by an
+    # equivalent `:ruby` filter block. Skips (and reports without correcting)
+    # groups that aren't a run of single-line scripts on contiguous lines.
+    #
+    # @return [Boolean] whether a correction was queued
+    def collect_merge(group)
+      return false unless autocorrect?
+      return false unless mergeable?(group)
+
+      merges << {
+        start: group.first.line - 1,
+        finish: group.last.line - 1,
+        lines: ruby_filter_lines(group),
+      }
+      true
+    end
+
+    # @return [Boolean] whether every script is a single line and the group
+    #   occupies a contiguous run of lines
+    def mergeable?(group)
+      group.none? { |node| node.script.include?("\n") } &&
+        group.each_cons(2).all? { |a, b| b.line == a.line + 1 }
+    end
+
+    # Builds the replacement lines: a `:ruby` filter marker at the group's
+    # indentation, followed by each script's body indented one level deeper.
+    #
+    # @return [Array<String>]
+    def ruby_filter_lines(group)
+      indent = document.source_lines[group.first.line - 1][/\A\s*/]
+      inner = indent + (indent.include?("\t") ? "\t" : '  ')
+      ["#{indent}:ruby", *group.map { |node| "#{inner}#{node.script.strip}" }]
+    end
+
+    # Applies the queued range replacements from the bottom up (so earlier line
+    # indices stay valid) and returns the rebuilt source.
+    #
+    # @return [String]
+    def merged_source
+      lines = document.source_lines.dup
+      merges.sort_by { |merge| -merge[:start] }.each do |merge|
+        lines[merge[:start]..merge[:finish]] = merge[:lines]
+      end
+      lines.join("\n")
+    end
+
+    def merges
+      @merges ||= []
+    end
   end
 end

data/lib/haml_lint/linter/html_attributes.rb

@@ -6,11 +6,80 @@ module HamlLint
   class Linter::HtmlAttributes < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
+    MESSAGE = "Prefer the hash attributes syntax (%tag{ lang: 'en' }) " \
+              'over HTML attributes syntax (%tag(lang=en))'
+
     def visit_tag(node)
       return unless node.html_attributes?
 
-      record_lint(node, "Prefer the hash attributes syntax (%tag{ lang: 'en' }) " \
-                        'over HTML attributes syntax (%tag(lang=en))')
+      record_lint(node, MESSAGE, corrected: correct(node))
+    end
+
+    private
+
+    # Rewrites the HTML attribute group `(...)` as a Ruby hash group `{...}`,
+    # preserving each attribute's value (static strings, booleans, and Ruby
+    # expressions alike).
+    #
+    # The conversion is skipped (the lint is still reported) when it can't be
+    # performed losslessly: when the tag already has a `{...}` hash group, when
+    # the `.class`/`#id` shorthand is present (its `class`/`id` are merged into
+    # the parsed attributes and can't be told apart from the HTML ones), or when
+    # the attribute list spans multiple lines.
+    #
+    # @return [Boolean] whether a correction was applied
+    def correct(node)
+      return false unless correctable?(node)
+      return false unless pairs = hash_pairs(node)
+
+      hash_source = "{ #{pairs.join(', ')} }"
+      return false unless parse_ruby(hash_source)
+
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      html_source = node.dynamic_attributes_source[:html]
+      return false unless line.include?(html_source)
+
+      correct_line(index, line.sub(html_source) { hash_source })
+    end
+
+    # Whether the tag's HTML attributes can be losslessly converted in place.
+    #
+    # @return [Boolean]
+    def correctable?(node)
+      return false if node.hash_attributes?
+      return false unless node.static_attributes_source.empty?
+
+      html_source = node.dynamic_attributes_source[:html]
+      !html_source.nil? && !html_source.include?("\n")
+    end
+
+    # Builds the `key => value` fragments for the tag's HTML attributes, or +nil+
+    # when one of the static values can't be safely serialized.
+    #
+    # @return [Array<String>, nil]
+    def hash_pairs(node)
+      pairs = node.static_attributes.map do |key, value|
+        return nil unless serializable?(value)
+
+        "#{key.inspect} => #{value.inspect}"
+      end
+
+      node.dynamic_attributes_sources.each do |literal|
+        inner = literal.strip.delete_prefix('{').delete_suffix('}').sub(/,\s*\z/, '').strip
+        pairs << inner unless inner.empty?
+      end
+
+      pairs
+    end
+
+    # @return [Boolean] whether the static attribute value round-trips through
+    #   +#inspect+ as a Ruby literal
+    def serializable?(value)
+      value.is_a?(String) || [true, false, nil].include?(value) || value.is_a?(Numeric)
     end
   end
 end

data/lib/haml_lint/linter/rubocop.rb

@@ -4,14 +4,14 @@ require 'rubocop'
 require 'tempfile'
 
 module HamlLint
-  # Runs RuboCop on the Ruby code contained within HAML templates.
+  # Runs RuboCop on the Ruby code contained within Haml templates.
   #
   # The processing is done by extracting a Ruby file that matches the content, including
-  # the indentation, of the HAML file. This way, we can run RuboCop with autocorrect
-  # and get new Ruby code which should be HAML compatible.
+  # the indentation, of the Haml file. This way, we can run RuboCop with autocorrect
+  # and get new Ruby code which should be Haml compatible.
   #
-  # The ruby extraction makes "Chunks" which wrap each HAML constructs. The Chunks can then
-  # use the corrected Ruby code to apply the corrections back in the HAML using logic specific
+  # The ruby extraction makes "Chunks" which wrap each Haml constructs. The Chunks can then
+  # use the corrected Ruby code to apply the corrections back in the Haml using logic specific
   # to each type of Chunk.
   #
   # The work is spread across the classes in the HamlLint::RubyExtraction module.
@@ -24,7 +24,7 @@ module HamlLint
         @offenses = []
         @config_store.instance_variable_set(:@options_config, config)
         # Using stdin also disables RuboCop's result cache, which is intentional:
-        # it reconstructs offense positions from the on-disk HAML, not the Ruby we
+        # it reconstructs offense positions from the on-disk Haml, not the Ruby we
         # inspected, so reusing it misreports lines (sds/haml-lint#593).
         @options[:stdin] = ruby_code
         super([haml_path])
@@ -282,7 +282,7 @@ module HamlLint
           end
         end
         record_lint(line, offense.message, offense.severity.name,
-                    corrected: autocorrected)
+                    corrected: autocorrected, correctable: offense.correctable?)
       end
     end
 
@@ -291,13 +291,15 @@ module HamlLint
     # @param line [#line] line number of the lint
     # @param message [String] error/warning to display to the user
     # @param severity [Symbol] RuboCop severity level for the offense
-    def record_lint(line, message, severity, corrected:)
+    # @param corrected [Boolean] whether RuboCop auto-corrected the offense
+    # @param correctable [Boolean] whether RuboCop is able to auto-correct the offense
+    def record_lint(line, message, severity, corrected:, correctable: false)
       # TODO: actual handling for RuboCop's new :info severity
       return if severity == :info
 
       @lints << HamlLint::Lint.new(self, @document.file, line, message,
                                    SEVERITY_MAP.fetch(severity, :warning),
-                                   corrected: corrected)
+                                   corrected: corrected, correctable: correctable)
     end
 
     # rubocop:disable Style/MutableConstant

data/lib/haml_lint/linter/ruby_comments.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint
-  # Checks for Ruby comments that can be written as HAML comments.
+  # Checks for Ruby comments that can be written as Haml comments.
   class Linter::RubyComments < Linter
     include LinterRegistry
 

data/lib/haml_lint/linter/space_before_script.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint
-  # Checks for Ruby script in HAML templates with no space after the `=`/`-`.
+  # Checks for Ruby script in Haml templates with no space after the `=`/`-`.
   class Linter::SpaceBeforeScript < Linter
     include LinterRegistry
 

data/lib/haml_lint/linter/unescaped_html.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint
-  # Flags HAML's unescaped-output markers (`!=`, `!~`, and the unescaped
+  # Flags Haml's unescaped-output markers (`!=`, `!~`, and the unescaped
   # plain-text `!`), which bypass HTML escaping.
   #
   # Like `raw`, `html_safe`, and `h()` in Rails, these make it easy to

data/lib/haml_lint/linter/unnecessary_string_output.rb

@@ -11,35 +11,99 @@ module HamlLint
   class Linter::UnnecessaryStringOutput < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
     MESSAGE = '`= "..."` should be rewritten as `...`'
 
     def visit_tag(node)
-      if tag_has_inline_script?(node) && inline_content_is_string?(node)
-        record_lint(node, MESSAGE)
-      end
+      return unless tag_has_inline_script?(node) && inline_content_is_string?(node)
+
+      plain = safe_plain_text(node.script)
+      corrected = plain ? correct_tag(node, plain) : false
+      record_lint(node, MESSAGE, corrected: corrected)
     end
 
     def visit_script(node)
-      # Some script nodes created by the HAML parser aren't actually script
+      # Some script nodes created by the Haml parser aren't actually script
       # nodes declared via the `=` marker. Check for it.
       return unless /\A\s*=/.match?(node.source_code)
+      return unless plain = safe_plain_text(node.script)
 
-      if outputs_string_literal?(node)
-        record_lint(node, MESSAGE)
-      end
+      record_lint(node, MESSAGE, corrected: correct_script(node, plain))
     end
 
     private
 
-    def outputs_string_literal?(script_node)
-      return unless tree = parse_ruby(script_node.script)
+    # Rewrites `%tag= "..."` as `%tag ...`, dropping the `=` marker and the
+    # surrounding quotes.
+    #
+    # @return [Boolean] whether a correction was applied
+    def correct_tag(node, plain)
+      marker = node.inline_marker_source.rstrip
+      # Only unwrap plain escaped output (`= "..."`); leave `!=`, `~`, and the
+      # whitespace-removal markers (`<`/`>`) untouched, as they change rendering.
+      return false unless /\A=\s*["']/.match?(marker)
+
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      return false unless line.rstrip.end_with?(marker)
+
+      prefix = line.rstrip[0...(line.rstrip.length - marker.length)]
+      correct_line(index, "#{prefix} #{plain}")
+    end
+
+    # Rewrites a standalone `= "..."` script as plain text, preserving the
+    # node's indentation.
+    #
+    # @return [Boolean] whether a correction was applied
+    def correct_script(node, plain)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      indentation = line[/\A\s*/]
+      correct_line(index, "#{indentation}#{plain}")
+    end
+
+    # Returns the Haml plain-text equivalent of a Ruby string literal script, or
+    # +nil+ when the script is not a string literal that can be safely unwrapped
+    # (i.e. unwrapping would change the rendered output).
+    #
+    # @return [String, nil]
+    def safe_plain_text(script)
+      return if script.include?("\n")
+      return unless tree = parse_ruby(script)
       return unless %i[str dstr].include?(tree.type)
+      return unless safely_unwrappable?(tree)
+
+      plain_text_from(tree)
+    rescue ::Parser::SyntaxError
+      # Gracefully ignore syntax errors, as that's managed by a different linter
+      nil
+    end
 
+    # Whether unwrapping the string literal into Haml plain text would preserve
+    # the rendered output.
+    #
+    # @return [Boolean]
+    def safely_unwrappable?(tree)
       !starts_with_reserved_character?(tree.children.first) &&
         !contains_escape_sequence?(tree) &&
         !contains_significant_whitespace?(tree)
-    rescue ::Parser::SyntaxError
-      # Gracefully ignore syntax errors, as that's managed by a different linter
+    end
+
+    # Reconstructs the Haml plain-text form of a string literal. Literal segments
+    # keep their text (with any `#{` escaped so Haml won't interpolate it), while
+    # interpolation segments are emitted verbatim in their `#{...}` form.
+    #
+    # @return [String]
+    def plain_text_from(tree)
+      string_segments(tree).map do |segment|
+        if segment.type == :str
+          segment.children.first.gsub('#{') { '\#{' }
+        else
+          segment.location.expression.source
+        end
+      end.join
     end
 
     # Returns whether a string starts with a character that would otherwise be
@@ -57,7 +121,7 @@ module HamlLint
 
     # Returns whether any literal portion of the string contains a backslash
     # escape (e.g. `\n`, `\t`, `\u202F`). Such escapes are interpreted inside
-    # a Ruby string but would be emitted verbatim as HAML plain text, so the
+    # a Ruby string but would be emitted verbatim as Haml plain text, so the
     # `= "..."` form is not equivalent to the unwrapped plain text.
     def contains_escape_sequence?(tree)
       string_segments(tree).any? do |segment|
@@ -65,7 +129,7 @@ module HamlLint
       end
     end
 
-    # Returns whether the string begins or ends with whitespace. HAML strips
+    # Returns whether the string begins or ends with whitespace. Haml strips
     # trailing whitespace from plain text (and leading whitespace denotes
     # indentation), so unwrapping such a string would change the output.
     def contains_significant_whitespace?(tree)

data/lib/haml_lint/linter.rb

@@ -56,7 +56,7 @@ module HamlLint
     end
 
     # Runs the linter against the given Haml document, raises if the file cannot be processed due to
-    # Syntax or HAML-Lint internal errors. (For testing purposes)
+    # Syntax or Haml-Lint internal errors. (For testing purposes)
     #
     # @param document [HamlLint::Document]
     def run_or_raise(document, autocorrect: nil)
@@ -164,7 +164,7 @@ module HamlLint
     # mutation path (`Document#change_source`), but only when the safety gate permits.
     # No-ops otherwise; `change_source` itself also no-ops when the source is unchanged.
     #
-    # @param new_source [String] the corrected HAML source
+    # @param new_source [String] the corrected Haml source
     def apply_autocorrect(new_source)
       return unless autocorrect?
       document.change_source(new_source)
@@ -212,11 +212,14 @@ module HamlLint
     #
     # @param node_or_line [#line] line number or node to extract the line number from
     # @param message [String] error/warning to display to the user
-    def record_lint(node_or_line, message, corrected: false)
+    # @param corrected [Boolean] whether the lint was fixed by auto-correct
+    # @param correctable [Boolean] whether the lint can be fixed by auto-correct;
+    #   defaults to whether this linter supports auto-correct at all
+    def record_lint(node_or_line, message, corrected: false, correctable: supports_autocorrect?)
       line = node_or_line.is_a?(Integer) ? node_or_line : node_or_line.line
       @lints << HamlLint::Lint.new(self, @document.file, line, message,
                                    config.fetch('severity', :warning).to_sym,
-                                   corrected: corrected)
+                                   corrected: corrected, correctable: correctable)
     end
 
     # Parse Ruby code into an abstract syntax tree.

data/lib/haml_lint/node_transformer.rb

@@ -4,7 +4,7 @@ module HamlLint
   # Responsible for transforming {Haml::Parser::ParseNode} objects into
   # corresponding {HamlLint::Tree::Node} objects.
   #
-  # The parse tree generated by HAML has a number of strange cases where certain
+  # The parse tree generated by Haml has a number of strange cases where certain
   # types of nodes are created that don't necessarily correspond to what one
   # would expect. This class is intended to isolate and handle these cases so
   # that linters don't have to deal with them.
@@ -16,7 +16,7 @@ module HamlLint
       @document = document
     end
 
-    # Converts the given HAML parse node into its corresponding HAML-Lint parse
+    # Converts the given Haml parse node into its corresponding Haml-Lint parse
     # node.
     #
     # @param haml_node [Haml::Parser::ParseNode]

data/lib/haml_lint/reporter/hash_reporter.rb

@@ -47,6 +47,8 @@ module HamlLint
       {
         severity: offense.severity,
         message: offense.message,
+        corrected: offense.corrected,
+        correctable: offense.correctable,
         location: {
           line: offense.line,
         },

data/lib/haml_lint/reporter/utils.rb

@@ -58,6 +58,8 @@ module HamlLint
       def print_message(lint)
         if lint.corrected
           log.success('[Corrected] ', false)
+        elsif lint.correctable
+          log.info('[Correctable] ', false)
         end
 
         if lint.linter

data/lib/haml_lint/ruby_extraction/base_chunk.rb

@@ -2,13 +2,13 @@
 
 module HamlLint::RubyExtraction
   # This is the base class for all of the Chunks of HamlLint::RubyExtraction.
-  # A Chunk represents a part of the HAML file that HamlLint::Linter::RuboCop
+  # A Chunk represents a part of the Haml file that HamlLint::Linter::RuboCop
   # is processing and will insert some Ruby code in a file passed to RuboCop.
   #
-  # There are chunks for most HAML concepts, even if they don't represent Ruby
+  # There are chunks for most Haml concepts, even if they don't represent Ruby
   # code. For example, there is a chunk that represents a `%div` tag, which
   # uses a `begin` in the generated Ruby to add indentation for the children
-  # of the %div in the Ruby file just like there is in the HAML file.
+  # of the %div in the Ruby file just like there is in the Haml file.
   class BaseChunk
     COMMA_CHANGES_LINES = true
 

data/lib/haml_lint/ruby_extraction/chunk_extractor.rb

@@ -4,7 +4,7 @@
 module HamlLint::RubyExtraction
   # Extracts "chunks" of the haml file into instances of subclasses of HamlLint::RubyExtraction::BaseChunk.
   #
-  # This is the first step of generating Ruby code from a HAML file to then be processed by RuboCop.
+  # This is the first step of generating Ruby code from a Haml file to then be processed by RuboCop.
   # See HamlLint::RubyExtraction::BaseChunk for more details.
   class ChunkExtractor
     include HamlLint::HamlVisitor
@@ -17,7 +17,7 @@ module HamlLint::RubyExtraction
                              ::Haml::Parser.new('', {})
                            end
 
-    # HAML strips newlines when handling multi-line statements (using pipes or trailing comma)
+    # Haml strips newlines when handling multi-line statements (using pipes or trailing comma)
     # We don't. So the regex must be fixed to correctly detect the start of the string.
     BLOCK_KEYWORD_REGEX = Regexp.new(Haml::Parser::BLOCK_KEYWORD_REGEX.source.sub('^', '\A'))
 
@@ -124,7 +124,7 @@ module HamlLint::RubyExtraction
     def visit_script(node, &block)
       raw_first_line = @original_haml_lines[node.line - 1]
 
-      # ==, !, !==, &, &== means interpolation (was needed before HAML 2.2... it's still supported)
+      # ==, !, !==, &, &== means interpolation (was needed before Haml 2.2... it's still supported)
       # =, !=, &= mean actual ruby code is coming
       # Anything else is interpolation
       # The regex lists the case for Ruby Code. The 3 cases and making sure they are not followed by another = sign
@@ -169,20 +169,20 @@ module HamlLint::RubyExtraction
           prev_chunk.node == node.parent
         # When an outputting script is nested under another outputting script,
         # we want to block them from being merged together by rubocop, because
-        # this doesn't make sense in HAML.
+        # this doesn't make sense in Haml.
         # Example:
         #   = if this_is_short
         #     = this_is_short_too
         # Could become (after RuboCop):
         #   HL.out = (HL.out = this_is_short_too if this_is_short)
-        # Or in (broken) HAML style:
+        # Or in (broken) Haml style:
         #   = this_is_short_too = if this_is_short
         # By forcing this to start a chunk, there will be extra placeholders which
         # blocks rubocop from merging the lines.
         must_start_chunk = true
       elsif script_prefix != '='
         # In the few cases where &= and != are used to start the script,
-        # We need to remember and put it back in the final HAML. Fusing scripts together
+        # We need to remember and put it back in the final Haml. Fusing scripts together
         # would make that basically impossible. Instead, a script has a "first_output_prefix"
         # field for this specific case
         must_start_chunk = true
@@ -301,7 +301,7 @@ module HamlLint::RubyExtraction
 
       if attributes_code&.start_with?('{')
         # HTML-style (parens) attributes, e.g. %div(foo=foo), arrive as a synthesized hash string
-        # like '{"foo" => foo,}'. That text isn't present verbatim in the HAML, so we can't map
+        # like '{"foo" => foo,}'. That text isn't present verbatim in the Haml, so we can't map
         # RuboCop corrections back and intentionally don't autocorrect it. We still extract the
         # attribute *values* as a non-correctable chunk so RuboCop sees variables used here;
         # otherwise they look unused (false Lint/UselessAssignment, plus unsafe autocorrect that
@@ -406,7 +406,7 @@ module HamlLint::RubyExtraction
       end
     end
 
-    # Visiting a HAML filter. Lines looking like `  :javascript` and the following lines
+    # Visiting a Haml filter. Lines looking like `  :javascript` and the following lines
     # that are nested.
     def visit_filter(node)
       # For unknown reasons, haml doesn't escape interpolations in filters.
@@ -521,14 +521,14 @@ module HamlLint::RubyExtraction
     # The first and last lines may not be the complete lines from the Haml, only the Ruby parts
     # and the indentation between the first and last list.
 
-    # HAML transforms the ruby code in many ways as it parses a document. Often removing lines and/or
+    # Haml transforms the ruby code in many ways as it parses a document. Often removing lines and/or
     # indentation. This is quite annoying for us since we want the exact layout of the code to analyze it.
     #
     # This function receives the code as haml provides it and the line where it starts. It returns
     # the actual code as it is in the haml file, keeping breaks and indentation for the following lines.
     # In addition, the start position of the code in the first line.
     #
-    # The rules for handling multiline code in HAML are as follow:
+    # The rules for handling multiline code in Haml are as follow:
     # * if the line being processed ends with a space and a pipe, then append to the line (without
     #   newlines) every following lines that also end with a space and a pipe. This means the last line of
     #   the "block" also needs a pipe at the end.
@@ -727,7 +727,7 @@ module HamlLint::RubyExtraction
 
     LOOP_KEYWORDS = %w[for until while].freeze
     def self.block_keyword(code)
-      # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
+      # Need to handle 'for'/'while' since regex stolen from Haml parser doesn't
       if (keyword = code[/\A\s*([^\s]+)\s+/, 1]) && LOOP_KEYWORDS.include?(keyword)
         return keyword
       end

data/lib/haml_lint/ruby_extraction/coordinator.rb

@@ -9,7 +9,7 @@ module HamlLint::RubyExtraction
   # * Preprocess the chunks to cleanup/fuse some of them.
   # * Generates the extracted ruby code from the Chunks.
   # * Handles the markers (see below)
-  # * Use the chunks to transfer corrections from corrected Ruby code back to HAML
+  # * Use the chunks to transfer corrections from corrected Ruby code back to Haml
   #
   # The generated Ruby code uses markers to wrap around the Ruby code from the chunks.
   # Those markers look like function calls, like: `haml_lint_marker_1`, so are valid ruby.
@@ -22,7 +22,7 @@ module HamlLint::RubyExtraction
     # @return [String] The prefix used for markers in the Ruby code
     attr_reader :marker_prefix
 
-    # @return [Array<String>] The ruby lines after extraction from HAML (before RuboCop)
+    # @return [Array<String>] The ruby lines after extraction from Haml (before RuboCop)
     attr_reader :assembled_ruby_lines
 
     # @return [Array<String>] The ruby lines after correction by RuboCop

data/lib/haml_lint/ruby_extraction/implicit_end_chunk.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::RubyExtraction
-  # HAML adds a `end` when code gets outdented. We need to add that to the Ruby too, this
+  # Haml adds a `end` when code gets outdented. We need to add that to the Ruby too, this
   # is the chunk for it.
   # However:
   # * we can't apply fixes to it, so there are no markers

data/lib/haml_lint/ruby_extraction/non_ruby_filter_chunk.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::RubyExtraction
-  # Chunk for dealing with every HAML filter other than `:ruby`
+  # Chunk for dealing with every Haml filter other than `:ruby`
   # The generated Ruby for these is just a HEREDOC, so interpolation is corrected at
   # the same time by RuboCop.
   class NonRubyFilterChunk < BaseChunk

data/lib/haml_lint/ruby_extraction/placeholder_marker_chunk.rb

@@ -5,7 +5,7 @@ module HamlLint::RubyExtraction
   # transfer the corrections it receives to the indentation of the associated lines.
   #
   # Also used so that Rubocop doesn't think that there is nothing in `if` and other such structures,
-  # so that it does corrections that make sense for the HAML.
+  # so that it does corrections that make sense for the Haml.
   class PlaceholderMarkerChunk < BaseChunk
     def initialize(node, marker_name, indent:, nb_lines: 1, **kwargs)
       @marker_name = marker_name

data/lib/haml_lint/ruby_extraction/script_chunk.rb

@@ -18,7 +18,7 @@ module HamlLint::RubyExtraction
     attr_reader :must_start_chunk
 
     # @return [Array<Integer>] Line indexes to ignore when building the source_map. For examples,
-    #   implicit `end` are on their own line in the Ruby file, but in the HAML, they are absent.
+    #   implicit `end` are on their own line in the Ruby file, but in the Haml, they are absent.
     attr_reader :skip_line_indexes_in_source_map
 
     # @return [HamlLint::RubyExtraction::BaseChunk] The previous chunk can affect how

data/lib/haml_lint/runner.rb

@@ -62,6 +62,8 @@ module HamlLint
     # @return [HamlLint::LinterSelector]
     attr_reader :linter_selector
 
+    PARALLEL_LINTER_SELECTOR_THREAD_KEY = :haml_lint_runner_parallel_linter_selectors
+
     # Returns a fresh selector for this run.
     #
     # LinterSelector memoizes linter instances, and linters mutate instance
@@ -73,6 +75,18 @@ module HamlLint
       HamlLint::LinterSelector.new(config, @options)
     end
 
+    # Returns a selector scoped to the current parallel worker.
+    #
+    # MRI runs Parallel.map in forked processes, so each worker can safely reuse
+    # its own linter instances. JRuby runs Parallel.map in threads, so this must
+    # be isolated per thread to avoid sharing mutable linter state.
+    #
+    # @return [HamlLint::LinterSelector]
+    def parallel_linter_selector
+      selectors = Thread.current[PARALLEL_LINTER_SELECTOR_THREAD_KEY] ||= {}.compare_by_identity
+      selectors[self] ||= build_linter_selector
+    end
+
     # Returns the {HamlLint::Configuration} that should be used given the
     # specified options.
     #
@@ -205,7 +219,7 @@ module HamlLint
     # @return [void]
     def warm_cache
       results = Parallel.map(sources) do |source|
-        lints = collect_lints(source, build_linter_selector, config)
+        lints = collect_lints(source, parallel_linter_selector, config)
         [source.path, lints]
       end
       @cache = results.to_h

data/lib/haml_lint/spec/matchers/report_lint.rb

@@ -11,10 +11,11 @@ module HamlLint
         expected_message = options[:message]
         expected_severity = options[:severity]
         expected_corrected = options[:corrected]
+        expected_correctable = options[:correctable]
 
         match do |linter|
           has_lints?(linter, expected_line, count, expected_message, expected_severity,
-                     expected_corrected)
+                     expected_corrected, expected_correctable)
         end
 
         failure_message do |linter|
@@ -65,15 +66,16 @@ module HamlLint
             (expected_severity ? " with severity '#{expected_severity}'" : '')
         end
 
-        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists
-                       expected_corrected)
+        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists,Naming
+                       expected_corrected, expected_correctable)
           if expected_line
             has_expected_line_lints?(linter,
                                      expected_line,
                                      count,
                                      expected_message,
                                      expected_severity,
-                                     expected_corrected)
+                                     expected_corrected,
+                                     expected_correctable)
           elsif count
             linter.lints.count == count
           elsif expected_message
@@ -83,12 +85,13 @@ module HamlLint
           end
         end
 
-        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists
+        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists,Naming
                                      expected_line,
                                      count,
                                      expected_message,
                                      expected_severity,
-                                     expected_corrected)
+                                     expected_corrected,
+                                     expected_correctable)
           if count
             multiple_lints_match_line?(linter, expected_line, count)
           elsif expected_message
@@ -97,6 +100,8 @@ module HamlLint
             lint_on_line_matches_severity?(linter, expected_line, expected_severity)
           elsif !expected_corrected.nil?
             lint_on_line_matches_corrected?(linter, expected_line, expected_corrected)
+          elsif !expected_correctable.nil?
+            lint_on_line_matches_correctable?(linter, expected_line, expected_correctable)
           else
             lint_lines(linter).include?(expected_line)
           end
@@ -126,6 +131,12 @@ module HamlLint
             .any? { |lint| lint.line == expected_line && lint.corrected == expected_corrected }
         end
 
+        def lint_on_line_matches_correctable?(linter, expected_line, expected_correctable)
+          linter
+            .lints
+            .any? { |lint| lint.line == expected_line && lint.correctable == expected_correctable }
+        end
+
         def lint_messages_match?(linter, expected_message)
           # Using === to support regex to match anywhere in the string
           lint_messages(linter).all? { |message| expected_message === message } # rubocop:disable Style/CaseEquality

data/lib/haml_lint/tree/comment_node.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::Tree
-  # Represents a visible XHTML comment in a HAML document.
+  # Represents a visible XHTML comment in a Haml document.
   class CommentNode < Node
   end
 end

data/lib/haml_lint/tree/doctype_node.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::Tree
-  # Represents a doctype definition for a HAML document.
+  # Represents a doctype definition for a Haml document.
   class DoctypeNode < Node
   end
 end

data/lib/haml_lint/tree/filter_node.rb

@@ -9,7 +9,7 @@ module HamlLint::Tree
     end
 
     def text
-      # Seems HAML strips the starting blank lines... without them, line numbers become offset,
+      # Seems Haml strips the starting blank lines... without them, line numbers become offset,
       # breaking the source_map and auto-correct
 
       nb_blank_lines = 0

data/lib/haml_lint/tree/haml_comment_node.rb

@@ -3,7 +3,7 @@
 require_relative '../directive'
 
 module HamlLint::Tree
-  # Represents a HAML comment node.
+  # Represents a Haml comment node.
   class HamlCommentNode < Node
     def directives
       directives = super
@@ -28,7 +28,7 @@ module HamlLint::Tree
     # Returns whether this comment contains a `locals` directive.
     #
     # @return [Boolean]
-    def is_strict_locals?
+    def is_strict_locals? # rubocop:disable Naming
       text.lstrip.start_with?('locals:')
     end
 

data/lib/haml_lint/tree/node.rb

@@ -3,13 +3,13 @@
 require_relative '../comment_configuration'
 
 module HamlLint::Tree
-  # Decorator class that provides a convenient set of helpers for HAML's
+  # Decorator class that provides a convenient set of helpers for Haml's
   # {Haml::Parser::ParseNode} struct.
   #
   # The goal is to abstract away the details of the underlying struct and
   # provide a cleaner and more uniform interface for getting information about a
   # node, as there are a number of weird/special cases in the struct returned by
-  # the HAML parser.
+  # the Haml parser.
   #
   # @abstract
   class Node
@@ -21,7 +21,7 @@ module HamlLint::Tree
     # Creates a node wrapping the given {Haml::Parser::ParseNode} struct.
     #
     # @param document [HamlLint::Document] Haml document that created this node
-    # @param parse_node [Haml::Parser::ParseNode] parse node created by HAML's parser
+    # @param parse_node [Haml::Parser::ParseNode] parse node created by Haml's parser
     def initialize(document, parse_node)
       @line = parse_node.line
       @document = document

data/lib/haml_lint/tree/root_node.rb

@@ -3,7 +3,7 @@
 require_relative 'null_node'
 
 module HamlLint::Tree
-  # Represents the root node of a HAML document that contains all other nodes.
+  # Represents the root node of a Haml document that contains all other nodes.
   class RootNode < Node
     # The name of the file parsed to build this tree.
     #
@@ -21,7 +21,7 @@ module HamlLint::Tree
         return node if node.line_numbers.cover?(line) && node != self
       end
 
-      # Because HAML doesn't leave any trace in the nodes when it merges lines that
+      # Because Haml doesn't leave any trace in the nodes when it merges lines that
       # end with a comma, it's harder to assign a node to the second line here:
       # = some_call user,
       #             foo, bar

data/lib/haml_lint/tree/silent_script_node.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::Tree
-  # Represents a HAML silent script node (`- some_expression`) which executes
+  # Represents a Haml silent script node (`- some_expression`) which executes
   # code without producing output.
   class SilentScriptNode < Node
     # The Ruby script contents parsed into a syntax tree.

data/lib/haml_lint/tree/tag_node.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::Tree
-  # Represents a tag node in a HAML document.
+  # Represents a tag node in a Haml document.
   class TagNode < Node
     # Computed set of attribute hashes code.
     #
@@ -46,7 +46,7 @@ module HamlLint::Tree
     # Returns whether this tag has a specified attribute.
     #
     # @return [true,false]
-    def has_hash_attribute?(attribute)
+    def has_hash_attribute?(attribute) # rubocop:disable Naming
       hash_attributes? && existing_attributes.include?(attribute)
     end
 
@@ -155,6 +155,18 @@ module HamlLint::Tree
       dynamic_attributes_source[:html][/\A\((.*)\)\z/, 1] if html_attributes?
     end
 
+    # The tag's static (non-Ruby) attributes parsed into a Ruby hash. Keys are
+    # strings and values are their literal parsed values (e.g. `true` for a
+    # boolean attribute such as `(required)`).
+    #
+    # @note When the tag uses the `.class`/`#id` shorthand, the resulting
+    #   `class`/`id` entries are merged into this hash as well.
+    #
+    # @return [Hash]
+    def static_attributes
+      @value[:attributes]
+    end
+
     # ID of the HTML tag.
     #
     # @return [String]

data/lib/haml_lint/utils.rb

@@ -233,7 +233,7 @@ module HamlLint
 
     # Returns true if line is only whitespace.
     # Note, this is not like blank? is rails. For nil, this returns false.
-    def is_blank_line?(line)
+    def is_blank_line?(line) # rubocop:disable Naming
       line && line.index(/\S/).nil?
     end
 

data/lib/haml_lint/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module HamlLint
-  VERSION = '0.74.0'
+  VERSION = '0.76.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml_lint
 version: !ruby/object:Gem::Version
-  version: 0.74.0
+  version: 0.76.0
 platform: ruby
 authors:
 - Shane da Silva