haml_lint 0.40.0 → 0.51.0

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)
 

data/lib/haml_lint/linter/no_placeholders.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HamlLint
+  # Checks that placeholder attributes are not used.
+  class Linter::NoPlaceholders < Linter
+    include LinterRegistry
+
+    MSG = 'Placeholders attributes should not be used.'
+    HASH_REGEXP = /:?['"]?placeholder['"]?(?::| *=>)/.freeze
+    HTML_REGEXP = /placeholder=/.freeze
+
+    def visit_tag(node)
+      return unless node.hash_attributes_source =~ HASH_REGEXP || node.html_attributes_source =~ HTML_REGEXP
+
+      record_lint(node, MSG)
+    end
+  end
+end

data/lib/haml_lint/linter/repeated_id.rb

@@ -8,13 +8,14 @@ module HamlLint
     MESSAGE_FORMAT = %{Do not repeat id "#%s" on the page}
 
     def visit_root(_node)
-      @id_map = Hash.new { |hash, key| hash[key] = [] }
+      @id_map = {}
     end
 
     def visit_tag(node)
       id = node.tag_id
       return unless id && !id.empty?
 
+      id_map[id] ||= []
       nodes = (id_map[id] << node)
       case nodes.size
       when 1 then nil

data/lib/haml_lint/linter/rubocop.rb

@@ -1,74 +1,253 @@
 # frozen_string_literal: true
 
-require 'haml_lint/ruby_extractor'
 require 'rubocop'
+require 'tempfile'
 
 module HamlLint
-  # Runs RuboCop on Ruby code contained within HAML templates.
+  # Runs RuboCop on the Ruby code contained within HAML templates.
+  #
+  # The processing is done by extracting a Ruby file that matches the content, including
+  # the indentation, of the HAML file. This way, we can run RuboCop with autocorrect
+  # and get new Ruby code which should be HAML compatible.
+  #
+  # The ruby extraction makes "Chunks" which wrap each HAML constructs. The Chunks can then
+  # use the corrected Ruby code to apply the corrections back in the HAML using logic specific
+  # to each type of Chunk.
+  #
+  # The work is spread across the classes in the HamlLint::RubyExtraction module.
   class Linter::RuboCop < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     # Maps the ::RuboCop::Cop::Severity levels to our own levels.
     SEVERITY_MAP = {
       error: :error,
       fatal: :error,
-
       convention: :warning,
       refactor: :warning,
       warning: :warning,
+      info: :info,
     }.freeze
 
-    def visit_root(_node)
-      extractor = HamlLint::RubyExtractor.new
-      extracted_source = extractor.extract(document)
+    # Debug fields, also used in tests
+    attr_accessor :last_extracted_source
+    attr_accessor :last_new_ruby_source
+
+    def visit_root(_node) # rubocop:disable Metrics
+      # Need to call the received block to avoid Linter automatically visiting children
+      # Only important thing is that the argument is not ":children"
+      yield :skip_children
+
+      if document.indentation && document.indentation != '  '
+        @lints <<
+          HamlLint::Lint.new(
+            self,
+            document.file,
+            nil,
+            "Only supported indentation is 2 spaces, got: #{document.indentation.dump}",
+            :error
+          )
+        return
+      end
+
+      @last_extracted_source = nil
+      @last_new_ruby_source = nil
+
+      coordinator = HamlLint::RubyExtraction::Coordinator.new(document)
+
+      extracted_source = coordinator.extract_ruby_source
+      if ENV['HAML_LINT_INTERNAL_DEBUG'] == 'true'
+        puts "------ Extracted ruby from #{@document.file}:"
+        puts extracted_source.source
+        puts '------'
+      end
+
+      @last_extracted_source = extracted_source
+
+      if extracted_source.source.empty?
+        @last_new_ruby_source = ''
+        return
+      end
+
+      new_ruby_code = process_ruby_source(extracted_source.source, extracted_source.source_map)
+
+      if @autocorrect && ENV['HAML_LINT_INTERNAL_DEBUG'] == 'true'
+        puts "------ Autocorrected extracted ruby from #{@document.file}:"
+        puts new_ruby_code
+        puts '------'
+      end
+
+      if @autocorrect && transfer_corrections?(extracted_source.source, new_ruby_code)
+        @last_new_ruby_source = new_ruby_code
+        transfer_corrections(coordinator, new_ruby_code)
+      end
+    end
+
+    def self.cops_names_not_supporting_autocorrect
+      return @cops_names_not_supporting_autocorrect if @cops_names_not_supporting_autocorrect
+      return [] unless ::RuboCop::Cop::Registry.respond_to?(:all)
+
+      cops_without_autocorrect = ::RuboCop::Cop::Registry.all.reject(&:support_autocorrect?)
+      # This cop cannot be disabled
+      cops_without_autocorrect.delete(::RuboCop::Cop::Lint::Syntax)
+      @cops_names_not_supporting_autocorrect = cops_without_autocorrect.map { |cop| cop.badge.to_s }.freeze
+    end
+
+    private
+
+    def rubocop_config_for(path)
+      user_config_path = ENV['HAML_LINT_RUBOCOP_CONF'] || config['config_file']
+      user_config_path ||= self.class.rubocop_config_store.user_rubocop_config_path_for(path)
+      user_config_path = File.absolute_path(user_config_path)
+      self.class.rubocop_config_store.config_object_pointing_to(user_config_path)
+    end
+
+    # Extracted here so that tests can stub this to always return true
+    def transfer_corrections?(initial_ruby_code, new_ruby_code)
+      initial_ruby_code != new_ruby_code
+    end
+
+    def transfer_corrections(coordinator, new_ruby_code)
+      begin
+        new_haml_lines = coordinator.haml_lines_with_corrections_applied(new_ruby_code)
+      rescue HamlLint::RubyExtraction::UnableToTransferCorrections => e
+        # Those are lints we couldn't correct. If haml-lint was called without the
+        # --auto-correct-only, then this linter will be called again without autocorrect,
+        # so the lints will be recorded then.
+        @lints = []
+
+        msg = "Corrections couldn't be transfered: #{e.message} - Consider linting the file " \
+              'without auto-correct and doing the changes manually.'
+        if ENV['HAML_LINT_DEBUG'] == 'true'
+          msg = "#{msg} DEBUG: Rubocop corrected Ruby code follows:\n#{new_ruby_code}\n------"
+        end
+
+        @lints << HamlLint::Lint.new(self, document.file, nil, msg, :error)
+        return
+      end
 
-      return if extracted_source.source.empty?
+      new_haml_string = new_haml_lines.join("\n")
 
-      find_lints(extracted_source.source, extracted_source.source_map)
+      if new_haml_validity_checks(new_haml_string)
+        document.change_source(new_haml_string)
+        true
+      else
+        false
+      end
+    end
+
+    def new_haml_validity_checks(new_haml_string)
+      new_haml_error = HamlLint::Utils.check_error_when_compiling_haml(new_haml_string)
+      return true unless new_haml_error
+
+      error_message = if new_haml_error.is_a?(::SyntaxError)
+                        'Corrections by haml-lint generate Haml that will have Ruby syntax error. Skipping.'
+                      else
+                        'Corrections by haml-lint generate invalid Haml. Skipping.'
+                      end
+
+      if ENV['HAML_LINT_DEBUG'] == 'true'
+        error_message = error_message.dup
+        error_message << "\nDEBUG: Here is the exception:\n#{new_haml_error.full_message}"
+
+        error_message << "DEBUG: This is the (wrong) HAML after the corrections:\n"
+        if new_haml_error.respond_to?(:line)
+          error_message << "(DEBUG: Line number of error in the HAML: #{new_haml_error.line})\n"
+        end
+        error_message << new_haml_string
+      else
+        # Those are lints we couldn't correct. If haml-lint was called without the
+        # --auto-correct-only, then this linter will be called again without autocorrect,
+        # so the lints will be recorded then. If it was called with --auto-correct-only,
+        # then we did nothing so it makes sense not to show the lints.
+        @lints = []
+      end
+
+      @lints << HamlLint::Lint.new(self, document.file, nil, error_message, :error)
+      false
     end
 
     # A single CLI instance is shared between files to avoid RuboCop
     # having to repeatedly reload .rubocop.yml.
-    def self.rubocop_cli
+    def self.rubocop_cli # rubocop:disable Lint/IneffectiveAccessModifier
       # The ivar is stored on the class singleton rather than the Linter instance
       # because it can't be Marshal.dump'd (as used by Parallel.map)
       @rubocop_cli ||= ::RuboCop::CLI.new
     end
 
-    private
+    def self.rubocop_config_store # rubocop:disable Lint/IneffectiveAccessModifier
+      @rubocop_config_store ||= RubocopConfigStore.new
+    end
 
-    # Executes RuboCop against the given Ruby code and records the offenses as
-    # lints.
+    # Executes RuboCop against the given Ruby code, records the offenses as
+    # lints, runs autocorrect if requested and returns the corrected ruby.
     #
-    # @param ruby [String] Ruby code
+    # @param ruby_code [String] Ruby code
     # @param source_map [Hash] map of Ruby code line numbers to original line
     #   numbers in the template
-    def find_lints(ruby, source_map)
-      filename =
-        if document.file
-          "#{document.file}.rb"
-        else
-          'ruby_script.rb'
-        end
+    # @return [String] The autocorrected Ruby source code
+    def process_ruby_source(ruby_code, source_map)
+      filename = document.file || 'ruby_script.rb'
 
-      with_ruby_from_stdin(ruby) do
-        extract_lints_from_offenses(lint_file(self.class.rubocop_cli, filename), source_map)
-      end
+      offenses, corrected_ruby = run_rubocop(self.class.rubocop_cli, ruby_code, filename)
+
+      extract_lints_from_offenses(offenses, source_map)
+      corrected_ruby
     end
 
-    # Defined so we can stub the results in tests
+    # Runs RuboCop, returning the offenses and corrected code. Raises when RuboCop
+    # fails to run correctly.
     #
-    # @param rubocop [RuboCop::CLI]
-    # @param file [String]
-    # @return [Array<RuboCop::Cop::Offense>]
-    def lint_file(rubocop, file)
-      status = rubocop.run(rubocop_flags << file)
-      unless [::RuboCop::CLI::STATUS_SUCCESS, ::RuboCop::CLI::STATUS_OFFENSES].include?(status)
+    # @param rubocop_cli [RuboCop::CLI] There to simplify tests by using a stub
+    # @param ruby_code [String] The ruby code to run through RuboCop
+    # @param path [String] the path to tell RuboCop we are running
+    # @return [Array<RuboCop::Cop::Offense>, String]
+    def run_rubocop(rubocop_cli, ruby_code, path) # rubocop:disable Metrics
+      rubocop_status = nil
+      stdout_str, stderr_str = HamlLint::Utils.with_captured_streams(ruby_code) do
+        rubocop_cli.config_store.instance_variable_set(:@options_config, rubocop_config_for(path))
+        rubocop_status = rubocop_cli.run(rubocop_flags + ['--stdin', path])
+      end
+
+      if ENV['HAML_LINT_INTERNAL_DEBUG'] == 'true'
+        if OffenseCollector.offenses.empty?
+          puts "------ No lints found by RuboCop in #{@document.file}"
+        else
+          puts "------ Raw lints found by RuboCop in #{@document.file}"
+          OffenseCollector.offenses.each do |offense|
+            puts offense
+          end
+          puts '------'
+        end
+      end
+
+      unless [::RuboCop::CLI::STATUS_SUCCESS, ::RuboCop::CLI::STATUS_OFFENSES].include?(rubocop_status)
+        if stderr_str.start_with?('Infinite loop')
+          msg = "RuboCop exited unsuccessfully with status #{rubocop_status}." \
+              ' This appears to be due to an autocorrection infinite loop.'
+          if ENV['HAML_LINT_DEBUG'] == 'true'
+            msg += " DEBUG: RuboCop's output:\n"
+            msg += stderr_str.strip
+          else
+            msg += " First line of RuboCop's output (Use --debug mode to see more):\n"
+            msg += stderr_str.each_line.first.strip
+          end
+
+          raise HamlLint::Exceptions::InfiniteLoopError, msg
+        end
+
         raise HamlLint::Exceptions::ConfigurationError,
-              "RuboCop exited unsuccessfully with status #{status}." \
-              ' Check the stack trace to see if there was a misconfiguration.'
+              "RuboCop exited unsuccessfully with status #{rubocop_status}." \
+              ' Here is its output to check the stack trace or see if there was' \
+              " a misconfiguration:\n#{stderr_str}"
       end
-      OffenseCollector.offenses
+
+      if @autocorrect
+        corrected_ruby = stdout_str.partition("#{'=' * 20}\n").last
+      end
+
+      [OffenseCollector.offenses, corrected_ruby]
     end
 
     # Aggregates RuboCop offenses and converts them to {HamlLint::Lint}s
@@ -76,24 +255,43 @@ module HamlLint
     #
     # @param offenses [Array<RuboCop::Cop::Offense>]
     # @param source_map [Hash]
-    def extract_lints_from_offenses(offenses, source_map)
-      dummy_node = Struct.new(:line)
+    def extract_lints_from_offenses(offenses, source_map) # rubocop:disable Metrics
+      offenses.each do |offense|
+        next if Array(config['ignored_cops']).include?(offense.cop_name)
+        autocorrected = offense.status == :corrected
+
+        # There will be another execution to deal with not auto-corrected stuff unless
+        # we are in autocorrect-only mode, where we don't want not auto-corrected stuff.
+        next if @autocorrect && !autocorrected && offense.cop_name != 'Lint/Syntax'
 
-      offenses.reject { |offense| Array(config['ignored_cops']).include?(offense.cop_name) }
-              .each do |offense|
-        record_lint(dummy_node.new(source_map[offense.line]), offense.message,
-                    offense.severity.name)
+        if ENV['HAML_LINT_INTERNAL_DEBUG']
+          line = offense.line
+        else
+          line = source_map[offense.line]
+
+          if line.nil? && offense.line == source_map.keys.max + 1
+            # The sourcemap doesn't include an entry for the line just after the last line,
+            # but rubocop sometimes does place offenses there.
+            line = source_map[offense.line - 1]
+          end
+        end
+        record_lint(line, offense.message, offense.severity.name,
+                    corrected: autocorrected)
       end
     end
 
     # Record a lint for reporting back to the user.
     #
-    # @param node [#line] node to extract the line number from
+    # @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(node, message, severity)
-      @lints << HamlLint::Lint.new(self, @document.file, node.line, message,
-                                   SEVERITY_MAP.fetch(severity, :warning))
+    def record_lint(line, message, severity, corrected:)
+      # 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)
     end
 
     # Returns flags that will be passed to RuboCop CLI.
@@ -101,25 +299,48 @@ module HamlLint
     # @return [Array<String>]
     def rubocop_flags
       flags = %w[--format HamlLint::OffenseCollector]
-      flags += ['--config', ENV['HAML_LINT_RUBOCOP_CONF']] if ENV['HAML_LINT_RUBOCOP_CONF']
-      flags += ['--stdin']
+      flags += ignored_cops_flags
+      flags += rubocop_autocorrect_flags
       flags
     end
 
-    # Overrides the global stdin to allow RuboCop to read Ruby code from it.
-    #
-    # @param ruby [String] the Ruby code to write to the overridden stdin
-    # @param _block [Block] the block to perform with the overridden stdin
-    # @return [void]
-    def with_ruby_from_stdin(ruby, &_block)
-      original_stdin = $stdin
-      stdin = StringIO.new
-      stdin.write(ruby)
-      stdin.rewind
-      $stdin = stdin
-      yield
-    ensure
-      $stdin = original_stdin
+    def rubocop_autocorrect_flags
+      return [] unless @autocorrect
+
+      rubocop_version = Gem::Version.new(::RuboCop::Version::STRING)
+
+      case @autocorrect
+      when :safe
+        if rubocop_version >= Gem::Version.new('1.30')
+          ['--autocorrect']
+        else
+          ['--auto-correct']
+        end
+      when :all
+        if rubocop_version >= Gem::Version.new('1.30')
+          ['--autocorrect-all']
+        else
+          ['--auto-correct-all']
+        end
+      else
+        raise "Unexpected autocorrect option: #{@autocorrect.inspect}"
+      end
+    end
+
+    # Because of autocorrect, we need to pass the ignored cops to RuboCop to
+    # prevent it from doing fixes we don't want.
+    # Because cop names changed names over time, we cleanup those that don't exist
+    # anymore or don't exist yet.
+    # This is not exhaustive, it's only for the cops that are in config/default.yml
+    def ignored_cops_flags
+      ignored_cops = config.fetch('ignored_cops', [])
+
+      if @autocorrect
+        ignored_cops += self.class.cops_names_not_supporting_autocorrect
+      end
+
+      return [] if ignored_cops.empty?
+      ['--except', ignored_cops.uniq.join(',')]
     end
   end
 
@@ -146,4 +367,77 @@ module HamlLint
       self.class.offenses += offenses
     end
   end
+
+  # To handle our need to force some configurations on RuboCop, while still allowing users
+  # to customize most of RuboCop using their own rubocop.yml config(s), we need to detect
+  # the effective RuboCop configuration for a specific file, and generate a new configuration
+  # containing our own "forced configuration" with a `inherit_from` that points on the
+  # user's configuration.
+  #
+  # This class handles all of this logic.
+  class RubocopConfigStore
+    def initialize
+      @dir_path_to_user_config_path = {}
+      @user_config_path_to_config_object = {}
+    end
+
+    # Build a RuboCop::Config from config/forced_rubocop_config.yml which inherits from the given
+    # user_config_path and return it's path.
+    def config_object_pointing_to(user_config_path)
+      if @user_config_path_to_config_object[user_config_path]
+        return @user_config_path_to_config_object[user_config_path]
+      end
+
+      final_config_hash = forced_rubocop_config_hash.dup
+
+      if user_config_path != ::RuboCop::ConfigLoader::DEFAULT_FILE
+        # If we manually inherit from the default RuboCop config, we may get warnings
+        # for deprecated stuff that is in it. We don't when we automatically
+        # inherit from it (which always happens)
+        final_config_hash['inherit_from'] = user_config_path
+      end
+
+      config_object = Tempfile.create(['.haml-lint-rubocop', '.yml']) do |tempfile|
+        tempfile.write(final_config_hash.to_yaml)
+        tempfile.close
+        ::RuboCop::ConfigLoader.configuration_from_file(tempfile.path)
+      end
+
+      @user_config_path_to_config_object[user_config_path] = config_object
+    end
+
+    # Find the path to the effective RuboCop configuration for a path (file or dir)
+    def user_rubocop_config_path_for(path)
+      dir = if File.directory?(path)
+              path
+            else
+              File.dirname(path)
+            end
+
+      @dir_path_to_user_config_path[dir] ||= ::RuboCop::ConfigLoader.configuration_file_for(dir)
+    end
+
+    # Returns the content (Hash) of config/forced_rubocop_config.yml after processing it's ERB content.
+    # Cached since it doesn't change between files
+    def forced_rubocop_config_hash
+      return @forced_rubocop_config_hash if @forced_rubocop_config_hash
+
+      content = File.read(File.join(HamlLint::HOME, 'config', 'forced_rubocop_config.yml'))
+      processed_content = HamlLint::Utils.process_erb(content)
+      hash = YAML.safe_load(processed_content)
+
+      if ENV['HAML_LINT_TESTING']
+        # In newer RuboCop versions, new cops are not enabled by default, and instead
+        # show a message until they are used. We just want a default for them
+        # to avoid spamming STDOUT. Making it "disable" reduces the chances of having
+        # the test suite start failing after a new cop gets added.
+        hash['AllCops'] ||= {}
+        if Gem::Version.new(::RuboCop::Version::STRING) >= Gem::Version.new('1')
+          hash['AllCops']['NewCops'] = 'disable'
+        end
+      end
+
+      @forced_rubocop_config_hash = hash.freeze
+    end
+  end
 end