haml_lint 0.73.0 → 0.75.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4157a366e322124248553b8119eaa33321000123121b8250eee8d0357131c65a
-  data.tar.gz: 631eb064ae4614ed9682ae88d85c276a87e0d2b6b35f19f51869601bbde31bce
+  metadata.gz: 8bb347cd92b5e23b37b8beb59d2c67f23eecd1e5778fdc45a7c4fbd73d14f854
+  data.tar.gz: 93836aaa95ab3bde6932969c81fb9e409c9806ab9057a1162580e1771f1edff7
 SHA512:
-  metadata.gz: 85756d43195b59d6582f2c352ef33084cab05d338cf56338d4b82b405890333894a12ebe1716301d831895fa24293594a506be6fc5ba0b112f7edd953963fd58
-  data.tar.gz: 0ef90b78b0d81b92bee5ff53a89d360ae831a1cf76b79f746a4a37b52e6a3e6d9a882af1ca206d1a0fe69e9cfceead2bbe5b1ea93ff3e90cef3d317aed2b06fb
+  metadata.gz: 5c5789d9ca6de3d2cae48ef91277b374ed84b477323389ccc7049d1d4e690ef1cb2252781074c902c7b82fa9dd332a36ace0d25652723841e170c89c9c805e15
+  data.tar.gz: 325df8db407db7567bf88db824dc2a071af3457c827b5268e96e6e2e17f0a63b6192974082ed8e4bab9ca0b645aacfbec981d7a25e6e9e7330d28f8c60df2123

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
 
@@ -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/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/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
@@ -137,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
@@ -147,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,7 +1,7 @@
 # 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

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