haml_lint 0.75.0 → 0.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bb347cd92b5e23b37b8beb59d2c67f23eecd1e5778fdc45a7c4fbd73d14f854
-  data.tar.gz: 93836aaa95ab3bde6932969c81fb9e409c9806ab9057a1162580e1771f1edff7
+  metadata.gz: 188328ae96f24b3a739665a5d3ccc7271a753afbe0ae63a1fbe3f33897492caa
+  data.tar.gz: 52b39c0992433545f610c7c18af3d06b224027edea3a9cdb97f71c7c1cf4f8c5
 SHA512:
-  metadata.gz: 5c5789d9ca6de3d2cae48ef91277b374ed84b477323389ccc7049d1d4e690ef1cb2252781074c902c7b82fa9dd332a36ace0d25652723841e170c89c9c805e15
-  data.tar.gz: 325df8db407db7567bf88db824dc2a071af3457c827b5268e96e6e2e17f0a63b6192974082ed8e4bab9ca0b645aacfbec981d7a25e6e9e7330d28f8c60df2123
+  metadata.gz: 31c53c1177acc7679c9f3c5b633a2b14278252f447ddea3b03c9d49e82d6e3d4587d44803e7b2b5ca677b726702c1a716cb02c848b8d2b71ed7bd402b78d8519
+  data.tar.gz: 253e971535ea2d8c38340e2e13a882fbe215cded72f5faa96b26dd88bb39024efe5b03d8334cc7692de4edbab2a7e49db9d4bb55a6a55e10319b52e3770a9ea4

data/lib/haml_lint/lint.rb

@@ -6,6 +6,9 @@ module HamlLint
     # @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

@@ -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/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
       # 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

data/lib/haml_lint/linter.rb

@@ -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/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/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|
@@ -66,14 +67,15 @@ module HamlLint
         end
 
         def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists,Naming
-                       expected_corrected)
+                       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
@@ -88,7 +90,8 @@ module HamlLint
                                      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/tag_node.rb

@@ -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/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module HamlLint
-  VERSION = '0.75.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.75.0
+  version: 0.76.0
 platform: ruby
 authors:
 - Shane da Silva