haml_lint 0.53.0 → 0.76.0

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/empty_object_reference.rb

@@ -5,11 +5,26 @@ module HamlLint
   class Linter::EmptyObjectReference < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_tag(node)
       return unless node.object_reference? &&
                     node.object_reference_source.strip.empty?
 
-      record_lint(node, 'Empty object reference should be removed')
+      corrected = correct_object_reference(node)
+      record_lint(node, 'Empty object reference should be removed', corrected: corrected)
+    end
+
+    private
+
+    # @return [Boolean]
+    def correct_object_reference(node)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      # `static_attributes_source` is just the `.class`/`#id` part (e.g. `.foo`),
+      # so the optional `%tag` group captures an explicit tag name when present.
+      static = Regexp.escape(node.static_attributes_source)
+      correct_line(index, line.sub(/\A(\s*(?:%[-:\w]+)?#{static})\[\s*\]/, '\1'))
     end
   end
 end

data/lib/haml_lint/linter/empty_script.rb

@@ -5,10 +5,40 @@ module HamlLint
   class Linter::EmptyScript < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
     def visit_silent_script(node)
-      return unless node.script =~ /\A\s*\Z/
+      return unless /\A\s*\Z/.match?(node.script)
+
+      # Only a childless `-` can be deleted; a `-` with children is degenerate
+      # but is still reported.
+      deletable = node.children.empty?
+      deleted_lines << (node.line - 1) if autocorrect? && deletable
+      record_lint(node, 'Empty script should be removed',
+                  corrected: autocorrect? && deletable)
+    end
+
+    def after_visit_root(node)
+      super
+      return if deleted_lines.empty?
+
+      kept = document.source_lines.reject.with_index do |_, index|
+        deleted_lines.include?(index)
+      end
+      apply_autocorrect(kept.join("\n"))
+    end
+
+    private
+
+    def reset_autocorrect_state
+      super
+      @deleted_lines = []
+    end
 
-      record_lint(node, 'Empty script should be removed')
+    # @return [Array<Integer>]
+    def deleted_lines
+      @deleted_lines ||= []
     end
   end
 end

data/lib/haml_lint/linter/final_newline.rb

@@ -5,6 +5,12 @@ module HamlLint
   class Linter::FinalNewline < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
+    # Run last during autocorrect, so any line-level corrections from other
+    # linters are applied before the trailing newline is normalized.
+    autocorrect_priority(1)
+
     def visit_root(root)
       return if document.source.empty?
       line_number = document.last_non_empty_line
@@ -12,14 +18,32 @@ module HamlLint
       node = root.node_for_line(line_number)
       return if node.disabled?(self)
 
-      ends_with_newline = document.source.end_with?("\n")
+      present = config['present'] ? true : false
+      corrected = corrected_source(present)
+      return if document.source == corrected
+
+      record_lint(line_number, message_for(present), corrected: autocorrect?)
+      apply_autocorrect(corrected)
+    end
+
+    private
+
+    def message_for(present)
+      if present
+        'Files should end with a trailing newline'
+      else
+        'Files should not end with a trailing newline'
+      end
+    end
 
-      if config['present']
-        unless ends_with_newline
-          record_lint(line_number, 'Files should end with a trailing newline')
-        end
-      elsif ends_with_newline
-        record_lint(line_number, 'Files should not end with a trailing newline')
+    # Normalizes only the single final newline. Collapsing multiple trailing
+    # newlines is `TrailingEmptyLines`' job, so a file that already ends with a
+    # newline is left untouched here under `present`.
+    def corrected_source(present)
+      if present
+        document.source.end_with?("\n") ? document.source : "#{document.source}\n"
+      else
+        document.source.sub(/\n+\z/, '')
       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/id_names.rb

@@ -24,7 +24,7 @@ module HamlLint
 
       style = config['style'] || 'lisp_case'
       matcher = STYLES[style]
-      record_lint(node, "`id` attribute must be in #{STYLIZED_NAMES[style]}") unless id =~ matcher
+      record_lint(node, "`id` attribute must be in #{STYLIZED_NAMES[style]}") unless id&.match?(matcher)
     end
   end
 end

data/lib/haml_lint/linter/implicit_div.rb

@@ -6,6 +6,8 @@ module HamlLint
   class Linter::ImplicitDiv < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_tag(node)
       return unless node.tag_name == 'div'
 
@@ -14,9 +16,20 @@ module HamlLint
       tag = node.source_code[/\s*([^\s={(\[]+)/, 1]
       return unless tag.start_with?('%div')
 
+      corrected = correct_implicit_div(node)
       record_lint(node,
                   "`#{tag}` can be written as `#{node.static_attributes_source}` " \
-                  'since `%div` is implicit')
+                  'since `%div` is implicit',
+                  corrected: corrected)
+    end
+
+    private
+
+    # @return [Boolean]
+    def correct_implicit_div(node)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      correct_line(index, line.sub(/\A(\s*)%div(?=[.#])/, '\1'))
     end
   end
 end

data/lib/haml_lint/linter/indentation.rb

@@ -11,7 +11,7 @@ module HamlLint
       tab: /^\t*(?! )/,
     }.freeze
 
-    LEADING_SPACES_REGEX = /^( +)(?! )/.freeze
+    LEADING_SPACES_REGEX = /^( +)(?! )/
 
     def visit_root(root)
       character = config['character'].to_sym
@@ -30,7 +30,7 @@ module HamlLint
       dummy_node = Struct.new(:line)
 
       document.source_lines.each_with_index do |line, index|
-        next if line =~ regex
+        next if line&.match?(regex)
 
         unless root.node_for_line(index).disabled?(self)
           record_lint dummy_node.new(index + 1), "Line contains #{wrong_characters} in indentation"

data/lib/haml_lint/linter/instance_variables.rb

@@ -10,7 +10,7 @@ module HamlLint
     # @param [HamlLint::Tree::RootNode] the root of a syntax tree
     # @return [true, false] whether the linter is enabled for the tree
     def visit_root(node)
-      @enabled = matcher.match(File.basename(node.file)) ? true : false
+      @enabled = matcher.match?(File.basename(node.file))
     end
 
     # Checks for instance variables in script nodes when the linter is enabled.
@@ -21,7 +21,7 @@ module HamlLint
       return unless enabled?
 
       if node.parsed_script.contains_instance_variables?
-        record_lint(node, "Avoid using instance variables in #{file_types} views")
+        record_lint(node, failure_message)
       end
     end
 
@@ -41,10 +41,27 @@ module HamlLint
 
       visit_script(node) ||
         if node.parsed_attributes.contains_instance_variables?
-          record_lint(node, "Avoid using instance variables in #{file_types} views")
+          record_lint(node, failure_message)
         end
     end
 
+    # Checks for instance variables in :ruby filters when the linter is enabled.
+    #
+    # @param [HamlLint::Tree::FilterNode]
+    # @return [void]
+    def visit_filter(node)
+      return unless enabled?
+      return unless node.filter_type == 'ruby'
+      return unless ast = parse_ruby(node.text)
+
+      ast.each_node do |i|
+        if i.type == :ivar
+          record_lint(node, failure_message)
+          break
+        end
+      end
+    end
+
     private
 
     # Tracks whether the linter is enabled for the file.
@@ -75,5 +92,13 @@ module HamlLint
     def matcher
       @matcher ||= Regexp.new(config['matchers'][file_types] || '\A_.*\.haml\z')
     end
+
+    # The error message when an ivar is found
+    #
+    # @api private
+    # @return [String]
+    def failure_message
+      "Avoid using instance variables in #{file_types} views"
+    end
   end
 end

data/lib/haml_lint/linter/leading_comment_space.rb

@@ -5,12 +5,24 @@ module HamlLint
   class Linter::LeadingCommentSpace < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_haml_comment(node)
       # Skip if the node spans multiple lines starting on the second line,
       # or starts with a space
-      return if node.text =~ /\A#*(\s*|\s+\S.*)$/
+      return if /\A#*(\s*|\s+\S.*)$/.match?(node.text)
+
+      corrected = correct_leading_space(node)
+      record_lint(node, 'Comment should have a space after the `#`', corrected: corrected)
+    end
+
+    private
 
-      record_lint(node, 'Comment should have a space after the `#`')
+    # @return [Boolean]
+    def correct_leading_space(node)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      correct_line(index, line.sub(/\A(\s*-#+)(?=\S)/, '\1 '))
     end
   end
 end

data/lib/haml_lint/linter/multiline_pipe.rb

@@ -26,12 +26,12 @@ module HamlLint
       # Plain text nodes are allowed to consist of a single pipe
       return if line.strip == '|'
 
-      record_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
+      record_lint(node, MESSAGE) if line.match?(MULTILINE_PIPE_REGEX)
     end
 
     private
 
-    MULTILINE_PIPE_REGEX = /\s+\|\s*$/.freeze
+    MULTILINE_PIPE_REGEX = /\s+\|\s*$/
 
     def line_text_for_node(node)
       document.source_lines[node.line - 1]
@@ -39,7 +39,7 @@ module HamlLint
 
     def check(node)
       line = line_text_for_node(node)
-      record_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
+      record_lint(node, MESSAGE) if line.match?(MULTILINE_PIPE_REGEX)
     end
   end
 end

data/lib/haml_lint/linter/multiline_script.rb

@@ -5,6 +5,9 @@ module HamlLint
   class Linter::MultilineScript < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
     # List of operators that can split a script into two lines that we want to
     # alert on.
     SPLIT_OPERATORS = %w[
@@ -31,8 +34,40 @@ module HamlLint
       check(node)
     end
 
+    def after_visit_root(node)
+      super
+      return if merges.empty?
+
+      apply_autocorrect(merged_source)
+    end
+
     private
 
+    def reset_autocorrect_state
+      super
+      @merges = []
+    end
+
+    def merged_source
+      lines = document.source_lines.dup
+      to_delete = apply_merges(lines)
+      lines.reject.with_index { |_, index| to_delete.include?(index) }.join("\n")
+    end
+
+    # Mutates +lines+ in place, folding each continuation script onto its chain
+    # root, and returns the line indices that should be deleted.
+    #
+    # @return [Array<Integer>]
+    def apply_merges(lines)
+      redirect = {}
+      merges.sort_by { |merge| merge[:from] }.map do |merge|
+        root = redirect.fetch(merge[:from], merge[:from])
+        redirect[merge[:succ_line]] = root
+        lines[root] = "#{lines[root].rstrip} #{merge[:succ_script]}"
+        merge[:succ_line]
+      end
+    end
+
     def check(node)
       # Condition occurs when scripts do not contain nested content, e.g.
       #
@@ -48,11 +83,36 @@ module HamlLint
       return unless node.children.empty?
 
       operator = node.script[/\s+(\S+)\z/, 1]
-      if SPLIT_OPERATORS.include?(operator)
-        record_lint(node,
-                    "Script with trailing operator `#{operator}` should be " \
-                    'merged with the script on the following line')
-      end
+      return unless SPLIT_OPERATORS.include?(operator)
+
+      corrected = collect_merge(node)
+      record_lint(node,
+                  "Script with trailing operator `#{operator}` should be " \
+                  'merged with the script on the following line',
+                  corrected: corrected)
+    end
+
+    def collect_merge(node)
+      return false unless autocorrect?
+
+      # Only merge with the immediately following sibling on the next line.
+      # `node.successor` would climb to an ancestor's sibling when this script is
+      # the last child of its block, which would pull a line from outside the
+      # block into it and change the semantics.
+      succ = node.subsequents.first
+      return false unless succ && %i[script silent_script].include?(succ.type)
+      return false unless succ.line == node.line + 1
+
+      merges << {
+        from: node.line - 1,
+        succ_line: succ.line - 1,
+        succ_script: succ.script.strip,
+      }
+      true
+    end
+
+    def merges
+      @merges ||= []
     end
   end
 end

data/lib/haml_lint/linter/no_placeholders.rb

@@ -6,8 +6,8 @@ module HamlLint
     include LinterRegistry
 
     MSG = 'Placeholders attributes should not be used.'
-    HASH_REGEXP = /:?['"]?placeholder['"]?(?::| *=>)/.freeze
-    HTML_REGEXP = /placeholder=/.freeze
+    HASH_REGEXP = /:?['"]?placeholder['"]?(?::| *=>)/
+    HTML_REGEXP = /placeholder=/
 
     def visit_tag(node)
       return unless node.hash_attributes_source =~ HASH_REGEXP || node.html_attributes_source =~ HTML_REGEXP