haml_lint 0.45.0 → 0.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d47102747f37b5169cf47af34064ea1346df32e5e530cc1d1f17c293de9a34e
-  data.tar.gz: aebecb2a1f37c6c0b20c67ec176c488bce59f667340d4f5a6cbe43736d7532bc
+  metadata.gz: b477cda9580216bbcc7434f0673bd4e8b36fa53cc22695cce4b25d5082921b5f
+  data.tar.gz: 8d404a3975a3def789672a4629b4bddb38a7b110083a731b801329369fae773b
 SHA512:
-  metadata.gz: e428d39889b5ab2857560151bea5e233d49ce80bac3fb1dc454e7f042567de7ec05471488c60d774e9506ce72399ac2e4d821d3e106126539740eafa78f2ab0f
-  data.tar.gz: efea4f7dbd70a5669f56f57871ffa29bdac38120e90943c3393ab941421ffd4cbfaf941226d71d707bbbda4800966d317350cb24f9cc15528a6418c42d4bd702
+  metadata.gz: 3e5a3e1b34815a356db1eb4ac1f10ca00e7d083a46f7b69cd8d3223ba6785d34eb628737ebd14d1b9867141bec328385794e329e096452df2b8c2868d42c4801
+  data.tar.gz: 2f27a33785a9f920359767524ab741bcc1edfaf8e52f3b469e264747e7ecf9f5861db308d33efc074634763889c499c187faa0ce8d455eee5618dfa6323d9f5b

data/bin/haml-lint

@@ -4,5 +4,5 @@
 require 'haml_lint'
 require 'haml_lint/cli'
 
-logger = HamlLint::Logger.new(STDOUT)
+logger = HamlLint::Logger.new($stdout)
 exit HamlLint::CLI.new(logger).run(ARGV)

data/config/default.yml

@@ -76,6 +76,9 @@ linters:
   MultilineScript:
     enabled: true
 
+  NoPlaceholders:
+    enabled: false
+
   ObjectReferenceAttributes:
     enabled: true
 
@@ -85,34 +88,9 @@ linters:
 
   RuboCop:
     enabled: true
-    # These cops are incredibly noisy when it comes to HAML templates, so we
-    # ignore them.
-    ignored_cops:
-      - Lint/BlockAlignment
-      - Lint/EndAlignment
-      - Lint/Void
-      - Layout/AlignHash # renamed to Layout/HashAlignment in rubocop 0.77
-      - Layout/AlignParameters # renamed to Layout/ParameterAlignment in rubocop 0.77
-      - Layout/ArgumentAlignment
-      - Layout/CaseIndentation
-      - Layout/ElseAlignment
-      - Layout/EndOfLine
-      - Layout/FirstHashElementIndentation
-      - Layout/HashAlignment
-      - Layout/IndentationWidth
-      - Layout/LineLength # renamed from Metrics/LineLength in rubocop 0.79.0
-      - Layout/ParameterAlignment
-      - Layout/TrailingBlankLines # renamed to Layout/TrailingEmptyLines in rubocop 0.77
-      - Layout/TrailingEmptyLines
-      - Layout/TrailingWhitespace
-      - Metrics/BlockLength
-      - Metrics/BlockNesting
-      - Metrics/LineLength
-      - Naming/FileName
-      - Style/FrozenStringLiteralComment
-      - Style/IfUnlessModifier
-      - Style/Next
-      - Style/WhileUntilModifier
+    # Users can ignore cops using this configuration instead of editing their rubocop configuration.
+    # Mostly there for backward compatibility.
+    ignored_cops: []
 
   RubyComments:
     enabled: true

data/config/forced_rubocop_config.yml

@@ -0,0 +1,156 @@
+# 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
+#
+# So these configuration should not be overwritable by users.
+
+Layout/ArgumentAlignment:
+  # The alternative, with_fixed_indentation, breaks because we sometimes remove indentation when
+  # dealing with multi-line scripts. (Because a line starting with "=" adds a "HL.out = " to the
+  # intermediary Ruby source, which requires indentation, and the removal of the indentation)
+  EnforcedStyle: with_first_argument
+
+Layout/ArrayAlignment:
+  # The alternative, with_fixed_indentation, breaks because we sometimes remove indentation when
+  # dealing with multi-line scripts. (Because a line starting with "=" adds a "HL.out = " to the
+  # intermediary Ruby source, which requires indentation, and the removal of the indentation)
+  EnforcedStyle: with_first_element
+
+# In Haml, there are edge cases when `when` is indented, such as this one:
+# - case 1
+#   - when 1
+#   - when 2
+#     foo
+# This generates 2 `end` when building Ruby.
+# So it's safer to make the `when` be not indented, to avoid auto-correct chains that could turn
+# a valid `if` into an invalid `case` such as above.
+Layout/CaseIndentation:
+  Enabled: true
+  EnforcedStyle: end
+  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.
+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.
+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
+Layout/EndOfLine:
+  Enabled: false
+
+Layout/ParameterAlignment:
+  # The alternative, with_fixed_indentation, breaks because we sometimes remove indentation when
+  # dealing with multi-line scripts. (Because a line starting with "=" adds a "HL.out = " to the
+  # intermediary Ruby source, which requires indentation, and the removal of the indentation)
+  EnforcedStyle: with_first_parameter
+
+# HamlLint generate lots of extra code which would make blocks much longer
+Metrics/BlockLength:
+  Enabled: false
+
+# The nesting may be due to the html's nesting nature... These lints are probably not helpful
+Metrics/BlockNesting:
+  Enabled: false
+
+# The file names are generated by HamlLint, so any related lint would be unfixable by the user
+Naming/FileName:
+  Enabled: false
+
+# 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
+# ruby would be invalid.
+Style/BlockDelimiters:
+  # So we need this cop to cleanup those cases and turn them to `end`.
+  Enabled: true
+  EnforcedStyle: line_count_based
+  # 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
+Style/CommentAnnotation:
+  AutoCorrect: false
+
+# If this was enabled, the equal sign would bubble up in a if like this:
+#   - if a
+#     = abc
+#   - else
+#     = bcd
+# Into:
+#   = if a
+#     - abc
+#   - else
+#     - bcd
+# Feels like this might be annoying or less visibly intuitive.
+Style/ConditionalAssignment:
+  Enabled: false
+
+# If this gets added, it wont do anything anyways.
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Looking at the changelog, this cop has quite a few bugfixes over time.
+# It still has problematic behaviors for us, such as breaking a line into multiple
+# ones with high indentation, which doesn't work for haml
+Style/IfUnlessModifier:
+  AutoCorrect: false
+
+# In some case, this cop can cause a change in the spacing.
+# In HAML 5.2, going from (absurd example for clarity):
+#   = 'abc' rescue nil
+#   = 'def'
+# to:
+#   = begin
+#     - 'abc'
+#   - rescue StandardError
+#     - nil
+#   = 'def'
+# Will remove the only whitespace (a \n) that is between the abc and the def.
+# This could affect spacing, ex: seeing "abc def" become "abcdef" when rendering
+# after running this auto-correct
+Style/RescueModifier:
+  AutoCorrect: false
+
+# 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
+Style/SymbolArray:
+  Enabled: false
+
+# This can easily change the order of the markers in the document, which result in un-transferable corrections
+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
+# case where a script can change line is after a comma.
+Style/WordArray:
+  AutoCorrect: false
+
+# Not RuboCop's job
+Layout/TrailingEmptyLines:
+  Enabled: false
+
+<% 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
+# responsible, at least from the user's point of view.
+Style/StringConcatenation:
+  Enabled: false
+<% end %>
+
+# There is already a linter dedicated to this in haml-lint
+Layout/LineLength:
+  Enabled: false

data/lib/haml_lint/adapter/haml_4.rb

@@ -18,9 +18,21 @@ module HamlLint
       # @param source [String] Haml code to parse
       # @param options [Haml::Options]
       def initialize(source, options = Haml::Options.new)
+        @source = source
         @parser = Haml::Parser.new(source, options)
       end
 
+      def precompile
+        # Haml uses the filters as part of precompilation... we don't care about those,
+        # but without this tweak, it would fail on filters that are not loaded.
+        real_defined = Haml::Filters.defined
+        Haml::Filters.instance_variable_set(:@defined, Hash.new { real_defined['plain'] })
+
+        ::Haml::Engine.new(source).precompiled
+      ensure
+        Haml::Filters.instance_variable_set(:@defined, real_defined)
+      end
+
       # @!method
       #   Parses the source code into an abstract syntax tree
       #
@@ -39,6 +51,12 @@ module HamlLint
       # @api private
       # @return [Haml::Parser] the Haml 4 parser
       attr_reader :parser
+
+      # The Haml code to parse
+      #
+      # @api private
+      # @return [String] Haml code to parse
+      attr_reader :source
     end
   end
 end

data/lib/haml_lint/adapter/haml_5.rb

@@ -30,6 +30,17 @@ module HamlLint
         parser.call(source)
       end
 
+      def precompile
+        # Haml uses the filters as part of precompilation... we don't care about those,
+        # but without this tweak, it would fail on filters that are not loaded.
+        real_defined = Haml::Filters.defined
+        Haml::Filters.instance_variable_set(:@defined, Hash.new { real_defined['plain'] })
+
+        ::Haml::Engine.new(source).precompiled
+      ensure
+        Haml::Filters.instance_variable_set(:@defined, real_defined)
+      end
+
       private
 
       # The Haml parser to adapt for HamlLint

data/lib/haml_lint/adapter/haml_6.rb

@@ -30,6 +30,17 @@ module HamlLint
         parser.call(source)
       end
 
+      def precompile
+        # Haml uses the filters as part of precompilation... we don't care about those,
+        # but without this tweak, it would fail on filters that are not loaded.
+        real_defined = Haml::Filters.registered
+        Haml::Filters.instance_variable_set(:@registered, Hash.new { real_defined['plain'] })
+
+        ::Haml::Engine.new.call(source)
+      ensure
+        Haml::Filters.instance_variable_set(:@registered, real_defined)
+      end
+
       private
 
       # The Haml parser to adapt for HamlLint

data/lib/haml_lint/cli.rb

@@ -7,7 +7,7 @@ require 'sysexits'
 
 module HamlLint
   # Command line application interface.
-  class CLI # rubocop:disable Metrics/ClassLength
+  class CLI
     # Create a CLI that outputs to the specified logger.
     #
     # @param logger [HamlLint::Logger]
@@ -34,9 +34,14 @@ module HamlLint
     # Given the provided options, execute the appropriate command.
     #
     # @return [Integer] exit status code
-    def act_on_options(options)
+    def act_on_options(options) # rubocop:disable Metrics
       configure_logger(options)
-
+      if options[:debug]
+        ENV['HAML_LINT_DEBUG'] = 'true'
+      end
+      if options[:internal_debug]
+        ENV['HAML_LINT_INTERNAL_DEBUG'] = 'true'
+      end
       if options[:help]
         print_help(options)
         Sysexits::EX_OK

data/lib/haml_lint/configuration_loader.rb

@@ -2,6 +2,7 @@
 
 require 'pathname'
 require 'yaml'
+require 'erb'
 
 module HamlLint
   # Manages configuration file loading.
@@ -31,7 +32,7 @@ module HamlLint
       def default_path_to_config
         directory = File.expand_path(Dir.pwd)
         config_file = possible_config_files(directory).find(&:file?)
-        config_file ? config_file.to_path : nil
+        config_file&.to_path
       end
 
       # Loads the built-in default configuration.
@@ -48,7 +49,7 @@ module HamlLint
       # @option context :exclude_files [Array<String>] files that should not
       #   be loaded even if they're requested via inherits_from
       # @return [HamlLint::Configuration]
-      def load_file(file, context = {})
+      def load_file(file, context = {}) # rubocop:disable Metrics
         context[:loaded_files] ||= []
         context[:loaded_files].map! { |config_file| File.expand_path(config_file) }
         context[:exclude_files] ||= []
@@ -85,13 +86,11 @@ module HamlLint
       #
       # @param file [String]
       # @return [HamlLint::Configuration]
-      def load_from_file(file)
-        hash =
-          if yaml = YAML.load_file(file)
-            yaml.to_hash
-          else
-            {}
-          end
+      def load_from_file(file) # rubocop:disable Metrics
+        content = File.read(file)
+
+        processed_content = HamlLint::Utils.process_erb(content)
+        hash = (YAML.safe_load(processed_content) || {}).to_hash
 
         if hash.key?('inherit_from')
           hash['inherits_from'] ||= []
@@ -157,7 +156,7 @@ module HamlLint
       #
       # @param gem_name [String] name of the gem
       # @param relative_config_path [String] path of the file to resolve, relative to the gem root
-      # @return [Stringg]
+      # @return [String]
       def gem_config_path(gem_name, relative_config_path)
         if defined?(Bundler)
           gem = Bundler.load.specs[gem_name].first

data/lib/haml_lint/document.rb

@@ -23,6 +23,14 @@ module HamlLint
     # @return [Array<String>] original source code as an array of lines
     attr_reader :source_lines
 
+    # @return [Boolean] true if the source was changed (by autocorrect)
+    attr_reader :source_was_changed
+
+    # @return [String] the indentation used in the file
+    attr_reader :indentation
+
+    attr_reader :unescape_interpolation_to_original_cache
+
     # Parses the specified Haml code into a {Document}.
     #
     # @param source [String] Haml code to parse
@@ -32,22 +40,80 @@ module HamlLint
     def initialize(source, options)
       @config = options[:config]
       @file = options.fetch(:file, STRING_SOURCE)
-
+      @source_was_changed = false
       process_source(source)
     end
 
+    # Returns the last non empty line of the document or 1 if all lines are empty
+    #
+    # @return [Integer] last non empty line of the document or 1 if all lines are empty
+    def last_non_empty_line
+      index = source_lines.rindex { |l| !l.empty? }
+      (index || 0) + 1
+    end
+
+    # Reparses the new source and remember that the document was changed
+    # Used when auto-correct does changes to the file. If the source hasn't changed,
+    # then the document will not be marked as changed.
+    #
+    # If the new_source fails to parse, automatically reparses the previous source
+    # to bring the document back to how it should be before re-raising the parse exception
+    #
+    # @param source [String] Haml code to parse
+    def change_source(new_source)
+      return if new_source == @source
+      check_new_source_compatible(new_source)
+
+      old_source = @source
+      begin
+        process_source(new_source)
+        @source_was_changed = true
+      rescue HamlLint::Exceptions::ParseError
+        # Reprocess the previous_source so that other linters can work on this document
+        # object from a clean slate
+        process_source(old_source)
+        raise
+      end
+      nil
+    end
+
+    def write_to_disk!
+      return unless @source_was_changed
+      if file == STRING_SOURCE
+        raise HamlLint::Exceptions::InvalidFilePath, 'Cannot write without :file option'
+      end
+      File.write(file, unstrip_frontmatter(source))
+      @source_was_changed = false
+    end
+
     private
 
     # @param source [String] Haml code to parse
     # @raise [HamlLint::Exceptions::ParseError] if there was a problem parsing
-    def process_source(source)
+    def process_source(source) # rubocop:disable Metrics/MethodLength
       @source = process_encoding(source)
       @source = strip_frontmatter(source)
-      @source_lines = @source.split(/\r\n|\r|\n/)
-
-      @tree = process_tree(HamlLint::Adapter.detect_class.new(@source).parse)
+      # the -1 is to keep the empty strings at the end of the array when the source
+      # ended with multiple new-lines
+      @source_lines = @source.split(/\r\n|\r|\n/, -1)
+      adapter = HamlLint::Adapter.detect_class.new(@source)
+      parsed_tree = adapter.parse
+      @indentation = adapter.send(:parser).instance_variable_get(:@indentation)
+      @tree = process_tree(parsed_tree)
+      @unescape_interpolation_to_original_cache =
+        Haml::Util.unescape_interpolation_to_original_cache_take_and_wipe
     rescue Haml::Error => e
-      error = HamlLint::Exceptions::ParseError.new(e.message, e.line)
+      location = if e.line
+                   "#{@file}:#{e.line}"
+                 else
+                   @file
+                 end
+      msg = if ENV['HAML_LINT_DEBUG'] == 'true'
+              "#{location} (DEBUG: source follows) - #{e.message}\n#{source}\n------"
+            else
+              "#{location} - #{e.message}"
+            end
+      error = HamlLint::Exceptions::ParseError.new(msg, e.line)
       raise error
     end
 
@@ -114,11 +180,26 @@ module HamlLint
         (---|\.\.\.)\s*$\n?/mx
 
       if config['skip_frontmatter'] && match = source.match(frontmatter)
-        newlines = match[0].count("\n")
-        source.sub!(frontmatter, "\n" * newlines)
+        @stripped_frontmatter = match[0]
+        @nb_newlines_for_frontmatter = match[0].count("\n")
+        source.sub!(frontmatter, "\n" * @nb_newlines_for_frontmatter)
       end
 
       source
     end
+
+    def check_new_source_compatible(new_source)
+      if @stripped_frontmatter && !new_source.start_with?("\n" * @nb_newlines_for_frontmatter)
+        raise HamlLint::Exceptions::IncompatibleNewSource,
+              "Internal error: new_source doesn't start with enough newlines for the Front Matter that was stripped"
+      end
+    end
+
+    def unstrip_frontmatter(source)
+      return source unless @stripped_frontmatter
+      check_new_source_compatible(source)
+
+      source.sub("\n" * @nb_newlines_for_frontmatter, @stripped_frontmatter)
+    end
   end
 end

data/lib/haml_lint/exceptions.rb

@@ -5,6 +5,12 @@ module HamlLint::Exceptions
   # Raised when a {Configuration} could not be loaded from a file.
   class ConfigurationError < StandardError; end
 
+  # Raised trying to change source with incompatible one (ex: due to frontmatter)
+  class IncompatibleNewSource < StandardError; end
+
+  # Raised when linter's autocorrection cause an infinite loop
+  class InfiniteLoopError < StandardError; end
+
   # Raised when invalid/incompatible command line options are provided.
   class InvalidCLIOption < StandardError; end
 

data/lib/haml_lint/extensions/haml_util_unescape_interpolation_tracking.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Haml does heavy transformations to strings that contain interpolation without a way
+# of perfectly inverting that transformation.
+#
+# We need this monkey patch to have a way of recovering the original strings as they
+# are in the haml files, so that we can use them and then autocorrect them.
+#
+# The HamlLint::Document carries over a hash of interpolation to original string. The
+# below patches are there to extract said information from Haml's parsing.
+module Haml::Util
+  # The cache for the current Thread (technically Fiber)
+  def self.unescape_interpolation_to_original_cache
+    Thread.current[:haml_lint_unescape_interpolation_to_original_cache] ||= {}
+  end
+
+  # As soon as a HamlLint::Document has finished processing a HAML souce, 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
+    value
+  end
+
+  # Overriding the unescape_interpolation method to store the return and original string
+  # in the cache.
+  def unescape_interpolation_with_original_tracking(str, escape_html = nil)
+    value = unescape_interpolation_without_original_tracking(str, escape_html)
+    Haml::Util.unescape_interpolation_to_original_cache[value] = str
+    value
+  end
+
+  alias unescape_interpolation_without_original_tracking unescape_interpolation
+  alias unescape_interpolation unescape_interpolation_with_original_tracking
+end

data/lib/haml_lint/file_finder.rb

@@ -40,7 +40,7 @@ module HamlLint
     #
     # @param patterns [Array<String>]
     # @return [Array<String>]
-    def extract_files_from(patterns) # rubocop:disable Metrics/MethodLength
+    def extract_files_from(patterns) # rubocop:disable Metrics
       files = []
 
       patterns.each do |pattern|
@@ -74,7 +74,7 @@ module HamlLint
     # @param path [String]
     # @return [String]
     def normalize_path(path)
-      path.start_with?(".#{File::SEPARATOR}") ? path[2..-1] : path
+      path.start_with?(".#{File::SEPARATOR}") ? path[2..] : path
     end
 
     # Whether the given file should be treated as a Haml file.

data/lib/haml_lint/lint.rb

@@ -3,6 +3,9 @@
 module HamlLint
   # 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 [String] file path to which the lint applies
     attr_reader :filename
 
@@ -25,12 +28,13 @@ module HamlLint
     # @param line [Fixnum]
     # @param message [String]
     # @param severity [Symbol]
-    def initialize(linter, filename, line, message, severity = :warning)
+    def initialize(linter, filename, line, message, severity = :warning, corrected: false) # rubocop:disable Metrics/ParameterLists
       @linter   = linter
       @filename = filename
       @line     = line || 0
       @message  = message
       @severity = Severity.new(severity)
+      @corrected = corrected
     end
 
     # Return whether this lint has a severity of error.
@@ -39,5 +43,10 @@ module HamlLint
     def error?
       @severity.error?
     end
+
+    def inspect
+      "#{self.class.name}(corrected=#{corrected}, filename=#{filename}, line=#{line}, " \
+        "linter=#{linter.class.name}, message=#{message}, severity=#{severity})"
+    end
   end
 end

data/lib/haml_lint/linter/final_newline.rb

@@ -7,18 +7,19 @@ module HamlLint
 
     def visit_root(root)
       return if document.source.empty?
+      line_number = document.last_non_empty_line
 
-      node = root.node_for_line(document.source_lines.count)
+      node = root.node_for_line(line_number)
       return if node.disabled?(self)
 
       ends_with_newline = document.source.end_with?("\n")
 
       if config['present']
         unless ends_with_newline
-          record_lint(node, 'Files should end with a trailing newline')
+          record_lint(line_number, 'Files should end with a trailing newline')
         end
       elsif ends_with_newline
-        record_lint(node, 'Files should not end with a trailing newline')
+        record_lint(line_number, 'Files should not end with a trailing newline')
       end
     end
   end

data/lib/haml_lint/linter/implicit_div.rb

@@ -11,7 +11,7 @@ module HamlLint
 
       return unless node.static_classes.any? || node.static_ids.any?
 
-      tag = node.source_code[/\s*([^\s={\(\[]+)/, 1]
+      tag = node.source_code[/\s*([^\s={(\[]+)/, 1]
       return unless tag.start_with?('%div')
 
       record_lint(node,

data/lib/haml_lint/linter/indentation.rb

@@ -7,8 +7,8 @@ module HamlLint
 
     # Allowed leading indentation for each character type.
     INDENT_REGEX = {
-      space: /^[ ]*(?!\t)/,
-      tab: /^\t*(?![ ])/,
+      space: /^ *(?!\t)/,
+      tab: /^\t*(?! )/,
     }.freeze
 
     LEADING_SPACES_REGEX = /^( +)(?! )/.freeze
@@ -45,7 +45,7 @@ module HamlLint
       root.children.each do |top_node|
         # once we've found one line with leading space, there's no need to check any more lines
         # `haml` will check indenting_at_start, deeper_indenting, inconsistent_indentation
-        break if top_node.children.find do |node|
+        break if top_node.children.find do |node| # rubocop:disable Lint/UnreachableLoop
           line = node.source_code
           leading_space = LEADING_SPACES_REGEX.match(line)