haml_lint 0.73.0 → 0.74.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4157a366e322124248553b8119eaa33321000123121b8250eee8d0357131c65a
-  data.tar.gz: 631eb064ae4614ed9682ae88d85c276a87e0d2b6b35f19f51869601bbde31bce
+  metadata.gz: 50729598b076118b141b2cf9552e8ada142c34ed52e3bd3e1a398948355ebfc2
+  data.tar.gz: e03f59f848bfa5a5a2d792e4ee347aaf10c956b7d47920594e87e9f283f8cb1f
 SHA512:
-  metadata.gz: 85756d43195b59d6582f2c352ef33084cab05d338cf56338d4b82b405890333894a12ebe1716301d831895fa24293594a506be6fc5ba0b112f7edd953963fd58
-  data.tar.gz: 0ef90b78b0d81b92bee5ff53a89d360ae831a1cf76b79f746a4a37b52e6a3e6d9a882af1ca206d1a0fe69e9cfceead2bbe5b1ea93ff3e90cef3d317aed2b06fb
+  metadata.gz: 7ce36a007738cb26bd4034a16cd00861f64db28ce0eefcb9dcef1edca25ee09d61521eed7dfa9b3b5bb558f0c379dde10fcbfdae3ecb72a3b1b3a24877db5188
+  data.tar.gz: 8601c85624f55a50dc33296ea88066eb935b7f5bc5843a2e2179204a7d2a259da9dcc95ee8543bc1b7205991f5d589e83f384d085e1884dfaa37ef8ed15fd9f2

data/config/default.yml

@@ -50,8 +50,8 @@ linters:
 
   Indentation:
     enabled: true
-    character: space # or tab
-    width: 2 # ignored if character == tab
+    character: space  # or tab
+    width: 2  # ignored if character == tab
 
   InlineStyles:
     enabled: true
@@ -88,8 +88,10 @@ linters:
 
   RuboCop:
     enabled: true
-    # Users can ignore cops using this configuration instead of editing their rubocop configuration.
-    # Mostly there for backward compatibility.
+    # 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,
+    # 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: []
 
   RubyComments:
@@ -118,6 +120,9 @@ linters:
   TrailingWhitespace:
     enabled: true
 
+  UnescapedHtml:
+    enabled: true
+
   UnnecessaryInterpolation:
     enabled: true
 

data/lib/haml_lint/cli.rb

@@ -100,7 +100,11 @@ module HamlLint
     # @return [HamlLint::Reporter]
     def reporter_from_options(options)
       if options[:auto_gen_config]
-        HamlLint::Reporter::DisabledConfigReporter.new(log, limit: options[:auto_gen_exclude_limit] || 15)
+        HamlLint::Reporter::DisabledConfigReporter.new(
+          log,
+          limit: options[:auto_gen_exclude_limit] || HamlLint::Reporter::DisabledConfigReporter::DEFAULT_EXCLUDE_LIMIT,
+          options: options
+        )
       else
         options.fetch(:reporter, HamlLint::Reporter::DefaultReporter).new(log)
       end

data/lib/haml_lint/document.rb

@@ -14,9 +14,6 @@ module HamlLint
     # @return [String] Haml template file path
     attr_reader :file
 
-    # @return [Boolean] true if source was read directly from `file` on-disk (rather than from stdin)
-    attr_reader :file_on_disk
-
     # @return [Boolean] true if source changes (from autocorrect) should be written to stdout instead of disk
     attr_reader :write_to_stdout
 
@@ -42,14 +39,12 @@ module HamlLint
     # @param source [String] Haml code to parse
     # @param options [Hash]
     # @option options :file [String] file name of document that was parsed
-    # @option options :file_on_disk [Boolean] true if source was read straight from `file` on disk
     # @option options :write_to_stdout [Boolean] true if source changes should be written to stdout
     # @raise [Haml::Parser::Error] if there was a problem parsing the document
     def initialize(source, options)
       @config = options[:config]
       @file = options.fetch(:file, STRING_SOURCE)
       @write_to_stdout = options[:write_to_stdout]
-      @file_on_disk = options[:file_on_disk] && @file != STRING_SOURCE
       @source_was_changed = false
       process_source(source)
     end

data/lib/haml_lint/linter/class_attribute_with_static_value.rb

@@ -18,15 +18,19 @@ module HamlLint
   class Linter::ClassAttributeWithStaticValue < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     STATIC_TYPES = %i[str sym].freeze
 
     VALID_CLASS_REGEX = /^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/
 
     def visit_tag(node)
-      return unless contains_class_attribute?(node.dynamic_attributes_sources)
+      class_value = static_class_value(node.dynamic_attributes_sources)
+      return unless class_value
 
+      corrected = correct_class_attribute(node, class_value)
       record_lint(node, 'Avoid defining `class` in attributes hash ' \
-                        'for static class names')
+                        'for static class names', corrected: corrected)
     end
 
     private
@@ -35,28 +39,64 @@ module HamlLint
       code.start_with?('{') && code.end_with?('}')
     end
 
-    def contains_class_attribute?(attributes_sources)
+    # @return [String, nil]
+    def static_class_value(attributes_sources)
       attributes_sources.each do |code|
         ast_root = parse_ruby(surrounded_by_braces?(code) ? code : "{#{code}}")
         next unless ast_root # RuboCop linter will report syntax errors
 
         ast_root.children.each do |pair|
-          return true if static_class_attribute_value?(pair)
+          value = static_class_attribute_value(pair)
+          return value if value
         end
       end
 
-      false
+      nil
     end
 
-    def static_class_attribute_value?(pair)
-      return false if (children = pair.children).empty?
+    # @return [String, nil]
+    def static_class_attribute_value(pair)
+      return nil if (children = pair.children).empty?
 
       key, value = children
 
-      STATIC_TYPES.include?(key.type) &&
-        key.children.first.to_sym == :class &&
-        STATIC_TYPES.include?(value.type) &&
-        value.children.first =~ VALID_CLASS_REGEX
+      return nil unless STATIC_TYPES.include?(key.type) &&
+                        key.children.first.to_sym == :class &&
+                        STATIC_TYPES.include?(value.type)
+
+      class_name = value.children.first.to_s
+      VALID_CLASS_REGEX.match?(class_name) ? class_name : nil
+    end
+
+    # @return [Boolean]
+    def correct_class_attribute(node, class_value)
+      hash_source = node.hash_attributes_source
+      return false unless hash_source
+      return false if hash_source.include?("\n")
+      return false unless node.dynamic_attributes_source.keys == [:hash]
+      return false unless sole_pair?(node.dynamic_attributes_sources)
+      return false if node.static_classes.flatten.include?(class_value)
+
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      old = "#{node.static_attributes_source}#{hash_source}"
+      return false unless line.include?(old)
+
+      new = "#{node.static_attributes_source}.#{class_value}"
+      correct_line(index, line.sub(old, new))
+    end
+
+    # Whether the attribute hash contains exactly one key/value pair (the class).
+    #
+    # @return [Boolean]
+    def sole_pair?(attributes_sources)
+      return false unless attributes_sources.size == 1
+
+      code = attributes_sources.first
+      ast_root = parse_ruby(surrounded_by_braces?(code) ? code : "{#{code}}")
+      return false unless ast_root
+
+      ast_root.children.size == 1
     end
   end
 end

data/lib/haml_lint/linter/classes_before_ids.rb

@@ -5,6 +5,8 @@ module HamlLint
   class Linter::ClassesBeforeIds < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     MSG = '%s should be listed before %s (%s should precede %s)'
 
     def visit_tag(node)
@@ -17,14 +19,27 @@ module HamlLint
         next unless next_val.start_with?(first) &&
                     current_val.start_with?(second)
 
+        corrected = correct_attribute_order(node, components)
         failure_message = format(MSG, *(attribute_type_order + [next_val, current_val]))
-        record_lint(node, failure_message)
+        record_lint(node, failure_message, corrected: corrected)
         break
       end
     end
 
     private
 
+    # @param node [HamlLint::Tree::TagNode]
+    # @param components [Array<String>] the `.class`/`#id` components in source order
+    # @return [Boolean]
+    def correct_attribute_order(node, components)
+      classes, ids = components.partition { |component| component.start_with?('.') }
+      new_source = (ids_first? ? ids + classes : classes + ids).join
+
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      correct_line(index, line.sub(node.static_attributes_source, new_source))
+    end
+
     def attribute_prefix_order
       default = %w[. #]
       default.reverse! if ids_first?

data/lib/haml_lint/linter/consecutive_comments.rb

@@ -5,6 +5,9 @@ module HamlLint
   class Linter::ConsecutiveComments < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+    autocorrect_safe(false)
+
     COMMENT_DETECTOR = ->(child) { child.type == :haml_comment }
 
     def visit_haml_comment(node)
@@ -16,13 +19,29 @@ module HamlLint
         config['max_consecutive'] + 1,
       ) do |group|
         group.each { |group_node| reported_nodes << group_node }
+        corrected = correct_group(group)
         record_lint(group.first,
-                    "#{group.count} consecutive comments can be merged into one")
+                    "#{group.count} consecutive comments can be merged into one",
+                    corrected: corrected)
       end
     end
 
     private
 
+    # @return [Boolean]
+    def correct_group(group)
+      first_index = group.first.line - 1
+      continuation_indent = "#{autocorrected_lines[first_index][/\A\s*/]}   "
+
+      changed = false
+      group[1..].each do |group_node|
+        index = group_node.line - 1
+        line = autocorrected_lines[index]
+        changed = true if correct_line(index, continuation_indent + line.sub(/\A\s*-#\s?/, ''))
+      end
+      changed
+    end
+
     def possible_group(node)
       node.subsequents.unshift(node)
     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 /\A\s*\Z/.match?(node.script)
 
-      record_lint(node, 'Empty script should be removed')
+      # 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
+
+    # @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/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/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 /\A#*(\s*|\s+\S.*)$/.match?(node.text)
 
-      record_lint(node, 'Comment should have a space after the `#`')
+      corrected = correct_leading_space(node)
+      record_lint(node, 'Comment should have a space after the `#`', corrected: corrected)
+    end
+
+    private
+
+    # @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_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/rubocop.rb

@@ -20,10 +20,12 @@ module HamlLint
     class Runner < ::RuboCop::Runner
       attr_reader :offenses
 
-      def run(haml_path, ruby_code, config:, allow_cache: false)
-        @allow_cache = allow_cache
+      def run(haml_path, ruby_code, config:)
         @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
+        # inspected, so reusing it misreports lines (sds/haml-lint#593).
         @options[:stdin] = ruby_code
         super([haml_path])
       end
@@ -40,20 +42,6 @@ module HamlLint
       def file_finished(_file, offenses)
         @offenses = offenses
       end
-
-      # RuboCop caches results by taking a hash of the file contents & path, among other things.
-      # It disables its cache when working on file-content from stdin.
-      # Unfortunately we always use RuboCop's stdin, even when we're linting a file on-disk.
-      # So, override RuboCop::Runner#cached_run? so that it'll allow caching results, so long
-      # as haml-lint itself isn't being invoked with files on stdin.
-      def cached_run?
-        return false unless @allow_cache
-
-        @cached_run ||=
-          (@options[:cache] == 'true' ||
-          (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) &&
-          !@options[:auto_gen_config]
-      end
     end
 
     include LinterRegistry
@@ -242,7 +230,7 @@ module HamlLint
     # @param path [String] the path to tell RuboCop we are running
     # @return [Array<RuboCop::Cop::Offense>, String]
     def run_rubocop(rubocop_runner, ruby_code, path) # rubocop:disable Metrics
-      rubocop_runner.run(path, ruby_code, config: rubocop_config_for(path), allow_cache: @document&.file_on_disk)
+      rubocop_runner.run(path, ruby_code, config: rubocop_config_for(path))
 
       if ENV['HAML_LINT_INTERNAL_DEBUG'] == 'true'
         if rubocop_runner.offenses.empty?

data/lib/haml_lint/linter/ruby_comments.rb

@@ -5,10 +5,13 @@ module HamlLint
   class Linter::RubyComments < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_silent_script(node)
-      if code_comment?(node)
-        record_lint(node, 'Use `-#` for comments instead of `- #`')
-      end
+      return unless code_comment?(node)
+
+      corrected = correct_comment(node)
+      record_lint(node, 'Use `-#` for comments instead of `- #`', corrected: corrected)
     end
 
     private
@@ -16,5 +19,12 @@ module HamlLint
     def code_comment?(node)
       node.script =~ /\A\s+#/
     end
+
+    # @return [Boolean]
+    def correct_comment(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/space_before_script.rb

@@ -5,6 +5,8 @@ module HamlLint
   class Linter::SpaceBeforeScript < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     MESSAGE_FORMAT = 'The %s symbol should have one space separating it from code'
 
     ALLOWED_SEPARATORS = [' ', '#'].freeze
@@ -33,18 +35,23 @@ module HamlLint
       # (need to do it this way as the parser strips whitespace from node)
       return unless tag_with_text[index - 1] != ' '
 
-      record_lint(node, MESSAGE_FORMAT % '=')
+      corrected = correct_inline_script(node, text)
+      record_lint(node, MESSAGE_FORMAT % '=', corrected: corrected)
     end
 
     def visit_script(node)
       # Plain text nodes with interpolation are converted to script nodes, so we
       # need to ignore them here.
       return unless document.source_lines[node.line - 1].lstrip.start_with?('=')
-      record_lint(node, MESSAGE_FORMAT % '=') if missing_space?(node)
+      return unless missing_space?(node)
+
+      record_lint(node, MESSAGE_FORMAT % '=', corrected: correct_leading_marker(node, '='))
     end
 
     def visit_silent_script(node)
-      record_lint(node, MESSAGE_FORMAT % '-') if missing_space?(node)
+      return unless missing_space?(node)
+
+      record_lint(node, MESSAGE_FORMAT % '-', corrected: correct_leading_marker(node, '-'))
     end
 
     private
@@ -53,5 +60,31 @@ module HamlLint
       text = node.script
       !ALLOWED_SEPARATORS.include?(text[0]) if text
     end
+
+    # Inserts one space after a leading `=`/`-` marker.
+    #
+    # @return [Boolean]
+    def correct_leading_marker(node, marker)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      escaped = Regexp.escape(marker)
+      correct_line(index, line.sub(/\A(\s*#{escaped})(?=[^\s#{escaped}])/, '\1 '))
+    end
+
+    # Inserts a space after the `=` marker introducing a tag's inline script.
+    #
+    # @return [Boolean]
+    def correct_inline_script(node, text)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+
+      pos = line.rindex("=#{text}")
+      if pos.nil? && (unquoted = strip_surrounding_quotes(text))
+        pos = line.rindex("=#{unquoted}")
+      end
+      return false unless pos
+
+      correct_line(index, "#{line[0..pos]} #{line[(pos + 1)..]}")
+    end
   end
 end