haml_lint 0.40.0 → 0.51.0

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HamlLint
+  # Checks for trailing empty lines.
+  class Linter::TrailingEmptyLines < Linter
+    include LinterRegistry
+
+    DummyNode = Struct.new(:line)
+
+    def visit_root(root)
+      return if document.source.empty?
+      line_number = document.last_non_empty_line
+
+      node = root.node_for_line(line_number)
+      return if node.disabled?(self)
+
+      return unless document.source.end_with?("\n\n")
+
+      record_lint(line_number, 'Files should not end with trailing empty lines')
+    end
+  end
+end

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

data/lib/haml_lint/logger.rb

@@ -30,7 +30,7 @@ module HamlLint
     #
     # @param output [String] the output to send
     # @param newline [true,false] whether to append a newline
-    def log(output, newline = true)
+    def log(output, newline = true) # rubocop:disable Style/OptionalBooleanParameter
       @out.print(output)
       @out.print("\n") if newline
     end
@@ -97,7 +97,7 @@ module HamlLint
 
     private
 
-    def color(code, output, newline = true)
+    def color(code, output, newline = true) # rubocop:disable Style/OptionalBooleanParameter
       log(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
     end
   end

data/lib/haml_lint/options.rb

@@ -32,7 +32,7 @@ module HamlLint
 
     private
 
-    def add_linter_options(parser)
+    def add_linter_options(parser) # rubocop:disable Metrics/MethodLength
       parser.on('--auto-gen-config', 'Generate a configuration file acting as a TODO list') do
         @options[:auto_gen_config] = true
       end
@@ -55,6 +55,20 @@ module HamlLint
       parser.on('-p', '--parallel', 'Run linters in parallel using available CPUs') do
         @options[:parallel] = true
       end
+
+      parser.on('-a', '--auto-correct', 'Auto-correct offenses (only when it’s safe)') do
+        @options[:autocorrect] = :safe
+      end
+
+      parser.on('-A', '--auto-correct-all', 'Auto-correct offenses (safe and unsafe)') do
+        @options[:autocorrect] = :all
+      end
+
+      parser.on('--auto-correct-only', "Only do auto-correct, don't lint. " \
+          'Also activates safe auto-correct if no auto-correct is selected') do
+        @options[:autocorrect_only] = true
+        @options[:autocorrect] ||= :safe
+      end
     end
 
     def add_report_options(parser)
@@ -99,7 +113,7 @@ module HamlLint
       end
     end
 
-    def add_info_options(parser)
+    def add_info_options(parser) # rubocop:disable Metrics/MethodLength
       parser.on('--show-linters', 'Display available linters') do
         @options[:show_linters] = true
       end
@@ -108,6 +122,16 @@ module HamlLint
         @options[:show_reporters] = true
       end
 
+      parser.on('-d', '--debug', 'Add some debug information to messages') do
+        @options[:debug] = true
+      end
+
+      parser.on('--internal-debug', 'Add lots of (internal) debug information.' \
+                " Also affects some lint's line numbers to skip sourcemap") do
+        @options[:debug] = true
+        @options[:internal_debug] = true
+      end
+
       parser.on_tail('-h', '--help', 'Display help documentation') do
         @options[:help] = parser.help
       end

data/lib/haml_lint/rake_task.rb

@@ -104,7 +104,7 @@ module HamlLint
     # @param task_args [Rake::TaskArguments]
     def run_cli(task_args)
       cli_args = parse_args
-      logger = quiet ? HamlLint::Logger.silent : HamlLint::Logger.new(STDOUT)
+      logger = quiet ? HamlLint::Logger.silent : HamlLint::Logger.new($stdout)
       result = HamlLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
 
       fail "#{HamlLint::APP_NAME} failed with exit code #{result}" unless result == 0
@@ -115,7 +115,7 @@ module HamlLint
     #
     # @param task_args [Rake::TaskArguments]
     def files_to_lint(task_args)
-      # Note: we're abusing Rake's argument handling a bit here. We call the
+      # NOTE: we're abusing Rake's argument handling a bit here. We call the
       # first argument `files` but it's actually only the first file--we pull
       # the rest out of the `extras` from the task arguments. This is so we
       # can specify an arbitrary list of files separated by commas on the

data/lib/haml_lint/reporter/hash_reporter.rb

@@ -14,7 +14,7 @@ module HamlLint
       lints = report.lints
       grouped = lints.group_by(&:filename)
 
-      report_hash = {
+      {
         metadata: metadata,
         files: grouped.map { |l| map_file(l) },
         summary: {
@@ -23,8 +23,6 @@ module HamlLint
           inspected_file_count: report.files.length,
         },
       }
-
-      report_hash
     end
 
     private

data/lib/haml_lint/reporter/offense_count_reporter.rb

@@ -10,7 +10,7 @@ module HamlLint
       return if total_count.zero?
 
       lints.group_by { |l| lint_type_group(l) }
-           .map { |linter, lints_for_this_linter| [linter, lints_for_this_linter.size] }.to_h
+           .transform_values(&:size)
            .sort_by { |_linter, lint_count| -lint_count }
            .each do |linter, lint_count|
         log.log "#{lint_count.to_s.ljust(total_count.to_s.length + 2)} #{linter}"

data/lib/haml_lint/reporter/utils.rb

@@ -56,6 +56,10 @@ module HamlLint
       # @param lint [HamlLint::Lint] the lint to print
       # @return [void]
       def print_message(lint)
+        if lint.corrected
+          log.success('[Corrected] ', false)
+        end
+
         if lint.linter
           log.success("#{lint.linter.name}: ", false)
         end
@@ -70,10 +74,15 @@ module HamlLint
       def print_summary(report)
         return unless log.summary_enabled
 
+        log.log('')
         print_summary_files(report)
-        print_summary_lints(report)
 
-        log.log ' detected'
+        print_summary_lints(report, is_append: true)
+
+        log.log ' detected', false
+
+        print_summary_corrected_lints(report, is_append: true)
+        log.log ''
       end
 
       # Prints a summary of the number of files linted in a report.
@@ -81,14 +90,17 @@ module HamlLint
       # @param report [HamlLint::Report] the report to print
       # @return [void]
       def print_summary_files(report)
-        log.log "\n#{pluralize('file', count: report.files.count)} inspected, ", false
+        log.log "#{pluralize('file', count: report.files.count)} inspected", false
       end
 
       # Prints a summary of the number of lints found in a report.
       #
       # @param report [HamlLint::Report] the report to print
+      # @param is_append [Boolean] if this is appending to a line. Will preffix with ", ".
       # @return [void]
-      def print_summary_lints(report)
+      def print_summary_lints(report, is_append:)
+        log.log ', ', false if is_append
+
         lint_count = report.lints.size
         lint_message = pluralize('lint', count: lint_count)
 
@@ -98,6 +110,23 @@ module HamlLint
           log.error lint_message, false
         end
       end
+
+      # Prints a summary of the number of lints corrected in a report.
+      #
+      # @param report [HamlLint::Report] the report to print
+      # @param is_append [Boolean] if this is appending to a line. Will preffix with ", ".
+      # @return [void]
+      def print_summary_corrected_lints(report, is_append:)
+        lint_count = report.lints.count(&:corrected)
+        return if lint_count == 0
+
+        log.log ', ', false if is_append
+
+        lint_message = pluralize('lint', count: lint_count)
+
+        log.info lint_message, false
+        log.log ' corrected', false
+      end
     end
   end
 end

data/lib/haml_lint/ruby_extraction/ad_hoc_chunk.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # This chunk just adds its code to the ruby, but does not attempt to transfer their correction
+  # in any way.
+  #
+  # Used for piece of code that just need to be in the generated ruby for reasons specific to
+  # the use cases, such as needing a `begin` to do add indentation.
+  class AdHocChunk < BaseChunk
+    def initialize(*args, **kwargs)
+      super(*args, **kwargs.merge(end_marker_indent: nil))
+    end
+
+    def wrap_in_markers
+      false
+    end
+
+    def transfer_correction(coordinator, all_corrected_ruby_lines, haml_lines); end
+
+    def skip_line_indexes_in_source_map
+      (0...@ruby_lines.size).to_a
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/base_chunk.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # This is the base class for all of the Chunks of HamlLint::RubyExtraction.
+  # A Chunk represents a part of the HAML file that HamlLint::Linter::RuboCop
+  # is processing and will insert some Ruby code in a file passed to RuboCop.
+  #
+  # There are chunks for most HAML concepts, even if they don't represent Ruby
+  # code. For example, there is a chunk that represents a `%div` tag, which
+  # uses a `begin` in the generated Ruby to add indentation for the children
+  # of the %div in the Ruby file just like there is in the HAML file.
+  class BaseChunk
+    COMMA_CHANGES_LINES = true
+
+    # @return [HamlLint::Tree::Node] Haml node that this comes from
+    attr_reader :node
+
+    # @return [Integer] First line index of the auto-correctable code in the Haml source
+    #   Usually same as node.line - 1, but some cases, such as interpolation in a filter will
+    #   will be different.
+    attr_reader :haml_line_index
+
+    # @return [Integer] Line number of the line marker in the ruby source placed before
+    #   this auto-correctable code
+    attr_reader :start_marker_line_number
+
+    # @return [Integer] The indentation (number of spaces) to use to index the marker
+    #   that follows this chunk. Unlike the marker before, this one can vary.
+    attr_reader :end_marker_indent
+
+    # @return [Array<String>] The ruby lines that this chunk will insert
+    attr_reader :ruby_lines
+
+    def initialize(node,
+                   ruby_lines,
+                   end_marker_indent:, haml_line_index: node.line - 1)
+      ruby_lines = [ruby_lines] if ruby_lines.is_a?(String)
+      @node = node
+      @ruby_lines = ruby_lines
+      @haml_line_index = haml_line_index
+      @end_marker_indent = end_marker_indent
+    end
+
+    # To be overridden in subclasses.
+    # Return a new chunk which is the result of fusing self with the given following chunk.
+    # If no fusion is possible, returns nil
+    def fuse(_following_chunk)
+      nil
+    end
+
+    # Overwrites haml_lines to match the Ruby code that was corrected by RuboCop which is in
+    # all_corrected_ruby_lines. This can change non-ruby parts to, especially for
+    # indentation.
+    #
+    # This will be called on ruby chunks in the reverse order they were created. Two benefits
+    # of this approach:
+    # * No need to track when lines in haml_lines are moved to apply changes later in the file
+    # * When fixing indentation of lines that follow a corrected line, those following lines will
+    #   already have been corrected and so require nothing.
+    # Can be overridden by subclasses to make it do nothing
+    def transfer_correction(coordinator, _all_corrected_ruby_lines, haml_lines)
+      to_ruby_lines = coordinator.extract_from_corrected_lines(@start_marker_line_number, @ruby_lines.size)
+      transfer_correction_logic(coordinator, to_ruby_lines, haml_lines)
+    end
+
+    # To be overriden by subclasses.
+    #
+    # Logic to transfer the corrections that turned from_ruby_lines into to_ruby_lines.
+    #
+    # This method only received the ruby code that belongs to this chunk. (It was
+    # extracted using #extract_from by #transfer_correction)
+    def transfer_correction_logic(_coordinator, _to_ruby_lines, _haml_lines)
+      raise "Implement #transfer_correction_logic in #{self.class.name}"
+    end
+
+    def start_marker_indent
+      ruby_lines.first[/ */].size
+    end
+
+    def haml_end_line_index
+      # the .max is needed to handle cases with 0 nb_haml_lines
+      [@haml_line_index + nb_haml_lines - 1, @haml_line_index].max
+    end
+
+    def nb_haml_lines
+      @ruby_lines.size - skip_line_indexes_in_source_map.size
+    end
+
+    def full_assemble(coordinator)
+      if wrap_in_markers
+        @start_marker_line_number = coordinator.add_marker(start_marker_indent,
+                                                           haml_line_index: haml_line_index)
+        assemble_in(coordinator)
+        coordinator.add_marker(@end_marker_indent, haml_line_index: haml_end_line_index)
+      else
+        assemble_in(coordinator)
+      end
+    end
+
+    def assemble_in(coordinator)
+      coordinator.add_lines(@ruby_lines,
+                            haml_line_index: haml_line_index,
+                            skip_indexes_in_source_map: skip_line_indexes_in_source_map)
+    end
+
+    def skip_line_indexes_in_source_map
+      []
+    end
+
+    def wrap_in_markers
+      true
+    end
+  end
+end