haml_lint 0.45.0 → 0.47.0

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/rubocop.rb

@@ -2,73 +2,253 @@
 
 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,51 +256,92 @@ 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.
     #
     # @return [Array<String>]
     def rubocop_flags
-      config_file = ENV['HAML_LINT_RUBOCOP_CONF'] || config['config_file']
       flags = %w[--format HamlLint::OffenseCollector]
-      flags += ['--config', config_file] if config_file
-      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
 
@@ -147,4 +368,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

data/lib/haml_lint/linter/space_before_script.rb

@@ -9,7 +9,7 @@ module HamlLint
 
     ALLOWED_SEPARATORS = [' ', '#'].freeze
 
-    def visit_tag(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def visit_tag(node) # rubocop:disable Metrics/CyclomaticComplexity
       # If this tag has inline script
       return unless node.contains_script?
 
@@ -18,15 +18,13 @@ module HamlLint
 
       tag_with_text = tag_with_inline_text(node)
 
-      unless index = tag_with_text.rindex(text)
-        # For tags with inline text that contain interpolation, the parser
-        # converts them to inline script by surrounding them in string quotes,
-        # e.g. `%p Hello #{name}` becomes `%p= "Hello #{name}"`, causing the
-        # above search to fail. Check for this case by removing added quotes.
-        unless (text_without_quotes = strip_surrounding_quotes(text)) &&
-               (index = tag_with_text.rindex(text_without_quotes))
-          return
-        end
+      # For tags with inline text that contain interpolation, the parser
+      # converts them to inline script by surrounding them in string quotes,
+      # e.g. `%p Hello #{name}` becomes `%p= "Hello #{name}"`, causing the
+      # above search to fail. Check for this case by removing added quotes.
+      if !(index = tag_with_text.rindex(text)) && !((text_without_quotes = strip_surrounding_quotes(text)) &&
+                     (index = tag_with_text.rindex(text_without_quotes)))
+        return
       end
 
       return if tag_with_text[index] == '#' # Ignore code comments

data/lib/haml_lint/linter/unnecessary_string_output.rb

@@ -35,7 +35,7 @@ module HamlLint
       return unless tree = parse_ruby(script_node.script)
       %i[str dstr].include?(tree.type) &&
         !starts_with_reserved_character?(tree.children.first)
-    rescue ::Parser::SyntaxError # rubocop:disable Lint/SuppressedException
+    rescue ::Parser::SyntaxError
       # Gracefully ignore syntax errors, as that's managed by a different linter
     end
 

data/lib/haml_lint/linter/view_length.rb

@@ -11,7 +11,7 @@ module HamlLint
 
     def visit_root(root)
       max = config['max']
-      line_count = document.source_lines.count
+      line_count = document.last_non_empty_line
       node = root.children.first
 
       if line_count > max && !node.disabled?(self)

data/lib/haml_lint/linter.rb

@@ -24,11 +24,8 @@ module HamlLint
     # Runs the linter against the given Haml document.
     #
     # @param document [HamlLint::Document]
-    def run(document)
-      @document = document
-      @lints = []
-      visit(document.tree)
-      @lints
+    def run(document, autocorrect: nil) # rubocop:disable Metrics
+      run_or_raise(document, autocorrect: autocorrect)
     rescue Parser::SyntaxError => e
       location = e.diagnostic.location
       @lints <<
@@ -39,6 +36,35 @@ module HamlLint
           e.to_s,
           :error
         )
+    rescue StandardError => e
+      msg = "Couldn't process the file".dup
+      if @autocorrect
+        # Those lints related to auto-correction were not saved, so don't display them
+        @lints = []
+        msg << " for autocorrect '#{@autocorrect}'. "
+      else
+        msg << ' for linting. '
+      end
+
+      msg << "#{e.class.name}: #{e.message}"
+      if ENV['HAML_LINT_DEBUG'] == 'true'
+        msg << "(DEBUG: Backtrace follows)\n#{e.backtrace.join("\n")}\n------"
+      end
+
+      @lints << HamlLint::Lint.new(self, document.file, nil, msg, :error)
+      @lints
+    end
+
+    # Runs the linter against the given Haml document, raises if the file cannot be processed due to
+    # Syntax or HAML-Lint internal errors. (For testing purposes)
+    #
+    # @param document [HamlLint::Document]
+    def run_or_raise(document, autocorrect: nil)
+      @document = document
+      @lints = []
+      @autocorrect = autocorrect
+      visit(document.tree)
+      @lints
     end
 
     # Returns the simple name for this linter.
@@ -48,25 +74,49 @@ module HamlLint
       self.class.name.to_s.split('::').last
     end
 
+    # Returns true if this linter supports autocorrect, false otherwise
+    #
+    # @return [Boolean]
+    def self.supports_autocorrect?
+      @supports_autocorrect || false
+    end
+
+    def supports_autocorrect?
+      self.class.supports_autocorrect?
+    end
+
     private
 
     attr_reader :config, :document
 
+    # Linters can call supports_autocorrect(true) in their top-level scope to indicate that
+    # they supports autocorrect.
+    #
+    # @params value [Boolean] The new value for supports_autocorrect
+    private_class_method def self.supports_autocorrect(value)
+      @supports_autocorrect = value
+    end
+
     # Record a lint for reporting back to the user.
     #
-    # @param node [#line] node to extract the line number from
+    # @param node_or_line [#line] line number or node to extract the line number from
     # @param message [String] error/warning to display to the user
-    def record_lint(node, message)
-      @lints << HamlLint::Lint.new(self, @document.file, node.line, message,
-                                   config.fetch('severity', :warning).to_sym)
+    def record_lint(node_or_line, message, corrected: false)
+      line = node_or_line.is_a?(Integer) ? node_or_line : node_or_line.line
+      @lints << HamlLint::Lint.new(self, @document.file, line, message,
+                                   config.fetch('severity', :warning).to_sym,
+                                   corrected: corrected)
     end
 
     # Parse Ruby code into an abstract syntax tree.
     #
     # @return [AST::Node]
     def parse_ruby(source)
+      self.class.ruby_parser.parse(source)
+    end
+
+    def self.ruby_parser # rubocop:disable Lint/IneffectiveAccessModifier
       @ruby_parser ||= HamlLint::RubyParser.new
-      @ruby_parser.parse(source)
     end
 
     # Remove the surrounding double quotes from a string, ignoring any

data/lib/haml_lint/linter_registry.rb

@@ -27,11 +27,9 @@ module HamlLint
       # @return [Array<Class>]
       def extract_linters_from(linter_names)
         linter_names.map do |linter_name|
-          begin
-            HamlLint::Linter.const_get(linter_name)
-          rescue NameError
-            raise NoSuchLinter, "Linter #{linter_name} does not exist"
-          end
+          HamlLint::Linter.const_get(linter_name)
+        rescue NameError
+          raise NoSuchLinter, "Linter #{linter_name} does not exist"
         end
       end
     end