haml_lint 0.40.0 → 0.51.0

data/lib/haml_lint/ruby_extraction/tag_script_chunk.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Chunk for handling outputting scripts after a tag, such as `%div= spam`
+  class TagScriptChunk < BaseChunk
+    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines) # rubocop:disable Metrics/AbcSize
+      # TODO: add checks that we have commas at the end of each line except the last one
+
+      from_ruby_line = @ruby_lines.first
+      to_ruby_line = to_ruby_lines.first
+
+      to_line_indent = to_ruby_line.index(/\S/)
+
+      from_ruby_line = from_ruby_line.sub(coordinator.script_output_prefix, '').sub(/^\s+/, '')
+      to_ruby_line = to_ruby_line.sub(coordinator.script_output_prefix, '').sub(/^\s+/, '')
+
+      affected_start_index = haml_lines[@haml_line_index].rindex(from_ruby_line)
+
+      haml_lines[@haml_line_index][affected_start_index..-1] = to_ruby_line
+
+      indent_delta = affected_start_index - coordinator.script_output_prefix.size - to_line_indent
+
+      HamlLint::Utils.map_after_first!(to_ruby_lines) do |line|
+        HamlLint::Utils.indent(line, indent_delta)
+      end
+
+      haml_lines[(@haml_line_index + 1)..haml_end_line_index] = to_ruby_lines[1..]
+    end
+  end
+end

data/lib/haml_lint/ruby_parser.rb

@@ -2,7 +2,6 @@
 
 require 'rubocop'
 require 'rubocop/ast/builder'
-require 'parser/current'
 
 module HamlLint
   # Parser for the Ruby language.
@@ -14,10 +13,21 @@ module HamlLint
   class RubyParser
     # Creates a reusable parser.
     def initialize
+      require_parser
       @builder = ::RuboCop::AST::Builder.new
       @parser = ::Parser::CurrentRuby.new(@builder)
     end
 
+    # Require the current parser version while suppressing the
+    # compliancy warning for minor version differences.
+    def require_parser
+      prev = $VERBOSE
+      $VERBOSE = nil
+      require 'parser/current'
+    ensure
+      $VERBOSE = prev
+    end
+
     # Parse the given Ruby source into an abstract syntax tree.
     #
     # @param source [String] Ruby source code

data/lib/haml_lint/runner.rb

@@ -24,6 +24,8 @@ module HamlLint
       @linter_selector = HamlLint::LinterSelector.new(config, options)
       @fail_fast = options.fetch(:fail_fast, false)
       @cache = {}
+      @autocorrect = options[:autocorrect]
+      @autocorrect_only = options[:autocorrect_only]
 
       report(options)
     end
@@ -88,9 +90,39 @@ module HamlLint
                                    e.line, e.to_s, :error)]
       end
 
-      linter_selector.linters_for_file(file).map do |linter|
-        linter.run(document)
-      end.flatten
+      linters = linter_selector.linters_for_file(file)
+      lint_arrays = []
+
+      if @autocorrect
+        lint_arrays << autocorrect_document(document, linters)
+      end
+
+      unless @autocorrect_only
+        lint_arrays << linters.map do |linter|
+          linter.run(document)
+        end
+      end
+      lint_arrays.flatten
+    end
+
+    # Out of the provided linters, runs those that support autocorrect
+    # against the specified document.
+    # Updates the document and returns the lints that were corrected.
+    #
+    # @param document [HamlLint::Document]
+    # @param linter_selector [HamlLint::LinterSelector]
+    # @return [Array<HamlLint::Lint>]
+    def autocorrect_document(document, linters)
+      lint_arrays = []
+
+      autocorrecting_linters = linters.select(&:supports_autocorrect?)
+      lint_arrays << autocorrecting_linters.map do |linter|
+        linter.run(document, autocorrect: @autocorrect)
+      end
+
+      document.write_to_disk!
+
+      lint_arrays
     end
 
     # Returns the list of files that should be linted given the specified

data/lib/haml_lint/spec/matchers/report_lint.rb

@@ -10,9 +10,11 @@ module HamlLint
         expected_line = options[:line]
         expected_message = options[:message]
         expected_severity = options[:severity]
+        expected_corrected = options[:corrected]
 
         match do |linter|
-          has_lints?(linter, expected_line, count, expected_message, expected_severity)
+          has_lints?(linter, expected_line, count, expected_message, expected_severity,
+                     expected_corrected)
         end
 
         failure_message do |linter|
@@ -63,13 +65,15 @@ module HamlLint
             (expected_severity ? " with severity '#{expected_severity}'" : '')
         end
 
-        def has_lints?(linter, expected_line, count, expected_message, expected_severity)
+        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists
+                       expected_corrected)
           if expected_line
             has_expected_line_lints?(linter,
                                      expected_line,
                                      count,
                                      expected_message,
-                                     expected_severity)
+                                     expected_severity,
+                                     expected_corrected)
           elsif count
             linter.lints.count == count
           elsif expected_message
@@ -79,17 +83,20 @@ module HamlLint
           end
         end
 
-        def has_expected_line_lints?(linter,
+        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists
                                      expected_line,
                                      count,
                                      expected_message,
-                                     expected_severity)
+                                     expected_severity,
+                                     expected_corrected)
           if count
             multiple_lints_match_line?(linter, expected_line, count)
           elsif expected_message
             lint_on_line_matches_message?(linter, expected_line, expected_message)
           elsif expected_severity
             lint_on_line_matches_severity?(linter, expected_line, expected_severity)
+          elsif !expected_corrected.nil?
+            lint_on_line_matches_corrected?(linter, expected_line, expected_corrected)
           else
             lint_lines(linter).include?(expected_line)
           end
@@ -101,9 +108,10 @@ module HamlLint
         end
 
         def lint_on_line_matches_message?(linter, expected_line, expected_message)
+          # Using === to support regex to match anywhere in the string
           linter
             .lints
-            .any? { |lint| lint.line == expected_line && lint.message == expected_message }
+            .any? { |lint| lint.line == expected_line && expected_message === lint.message } # rubocop:disable Style/CaseEquality
         end
 
         def lint_on_line_matches_severity?(linter, expected_line, expected_severity)
@@ -112,8 +120,15 @@ module HamlLint
             .any? { |lint| lint.line == expected_line && lint.severity == expected_severity }
         end
 
+        def lint_on_line_matches_corrected?(linter, expected_line, expected_corrected)
+          linter
+            .lints
+            .any? { |lint| lint.line == expected_line && lint.corrected == expected_corrected }
+        end
+
         def lint_messages_match?(linter, expected_message)
-          lint_messages(linter).all? { |message| message == expected_message }
+          # Using === to support regex to match anywhere in the string
+          lint_messages(linter).all? { |message| expected_message === message } # rubocop:disable Style/CaseEquality
         end
 
         def lint_lines(linter)

data/lib/haml_lint/spec/normalize_indent.rb

@@ -6,8 +6,8 @@ module HamlLint
     # for writing code without having the leading indentation count.
     module IndentNormalizer
       def normalize_indent(code)
-        leading_indent = code[/^(\s*)/, 1]
-        code.lstrip.gsub(/\n#{leading_indent}/, "\n")
+        leading_indent = code[/([ \t]*)/, 1]
+        code.gsub(/^#{leading_indent}/, '')
       end
     end
   end

data/lib/haml_lint/spec/shared_linter_context.rb

@@ -14,13 +14,21 @@ module HamlLint
           }
         end
 
+        let(:autocorrect) { nil }
+
         let(:config) { options[:config].for_linter(described_class) }
 
         let(:document) { HamlLint::Document.new(normalize_indent(haml), options) }
 
+        # :run_or_raise, :run, or nil to not auto-call something
+        let(:run_method_to_use) { :run_or_raise }
+
         subject { described_class.new(config) }
 
-        before { subject.run(document) }
+        before do
+          next unless run_method_to_use
+          subject.send(run_method_to_use, document, autocorrect: autocorrect)
+        end
       end
     end
   end

data/lib/haml_lint/spec/shared_rubocop_autocorrect_context.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+# Makes writing tests for linters a lot DRYer by taking any currently `haml`
+# variable defined via `let` and normalizing it and running the linter against
+# it, allowing specs to simply specify whether a lint was reported.
+
+module HamlLint
+  module Spec
+    module SharedRubocopAutocorrectContext
+      RSpec.shared_context 'rubocop_autocorrect' do
+        # Setting ENV['STUB_RUBOCOP'] to 1 or true makes rubocop tests faster by not involving rubocop.
+        # It is sometimes automatically activated for tests which need a different Rubocop version
+        stub_rubocop_env_result = %w[1 true].include?(ENV['STUB_RUBOCOP'])
+
+        let(:stub_rubocop?) do |example|
+          # Tries to match `{% rubocop_version <= '1.2' %}`, extracting the operator and the "number"
+          rubocop_version_regex = /\{%\s*rubocop_version\s*([^\w\s]+?)\s*['"]?(\d+(\.\d+)*)['"]?\s*%\}/
+          requirements = example.metadata[:full_description].scan(rubocop_version_regex)
+
+          # This can be used by the requirements in eval
+          rubocop_version = HamlLint::VersionComparer.for_rubocop
+
+          accepted = requirements.all? do |(operator, version)|
+            rubocop_version.send(operator, version)
+          end
+
+          next true unless accepted
+
+          # Doing this last so that exceptions in the requirements always fail
+          next true if stub_rubocop_env_result
+
+          false
+        end
+
+        let(:supported_haml?) do |example|
+          # Tries to match `{% haml_version >= '5' %}`, extracting the operator and the "number"
+          haml_version_regex = /\{%\s*haml_version\s*([^\w\s]+?)\s*['"]?(\d+(\.\d+)*)['"]?\s*%\}/
+          requirements = example.metadata[:full_description].scan(haml_version_regex)
+
+          # This can be used by the requirements in eval
+          haml_version = HamlLint::VersionComparer.for_haml
+
+          requirements.all? do |(operator, version)|
+            haml_version.send(operator, version)
+          end
+        end
+
+        before do
+          if stub_rubocop?
+            skip if end_ruby.include?('SKIP')
+            subject.stub(:process_ruby_source).and_return(end_ruby)
+          end
+          subject.stub(:transfer_corrections?).and_return(true)
+        end
+
+        include_context 'linter'
+        # The goal is not to test rubocop the gem, so no need to test the details using both
+        # :safe and :all
+        let(:autocorrect) { :all }
+
+        # We want want to do error handling ourself
+        let(:run_method_to_use) { nil }
+
+        let(:steps_parts) do
+          parts = steps_string.split(/^[ \t]*---[ \t]*\n/, -1)
+          raise "Expected 4 steps, got: #{parts.size}" if parts.size != 4
+          parts
+        end
+
+        let(:start_haml) { steps_parts[0] }
+
+        let(:start_ruby) do
+          lines = steps_parts[1].split("\n", -1)
+          current_matching_line = 1
+          @source_map = {}
+          lines.each.with_index do |line, i|
+            next unless line =~ /\S/
+            mo = line.match(/^(.*?)\$?\s*\$\$(\d+)$/)
+            if mo
+              lines[i] = mo[1]
+              current_matching_line = Integer(mo[2])
+            end
+            @source_map[i + 1] = current_matching_line
+          end
+          lines.join("\n")
+        end
+
+        let(:source_map) do
+          start_ruby
+          @source_map
+        end
+
+        let(:end_ruby) { steps_parts[2] }
+
+        let(:end_haml) { steps_parts[3] }
+
+        # Used by the 'linter' context
+        let(:haml) { start_haml }
+
+        # steps_string is string of multiple lines describing the steps that
+        # the code will take:
+        # 1) input haml
+        # 2) extracted ruby
+        # 3) the corrected ruby
+        # 4) the corrected haml
+        # Each steps is delimited by a line with ---
+        def follows_steps # rubocop:disable Metrics
+          skip unless supported_haml?
+
+          begin
+            subject.run_or_raise(document, autocorrect: autocorrect)
+          rescue StandardError => e
+            exception_while_running = e
+          end
+
+          syntax_lints = subject.lints.select { |lint| lint.message =~ %r{Lint/Syntax} }
+
+          if start_ruby.strip != 'SKIP' && subject.last_extracted_source
+            matcher = eq(start_ruby)
+            subject.last_extracted_source.source.should(
+              matcher,
+              -> { "Extracted Ruby is different from expected. #{matcher.failure_message}\n#{format_lints}" }
+            )
+          end
+
+          syntax_lints.should(be_empty, "Generated Ruby has Syntax Lints:\n#{format_lints(syntax_lints)}")
+
+          if end_ruby.strip != 'SKIP' && subject.last_new_ruby_source
+            matcher = eq(end_ruby)
+            subject.last_new_ruby_source.should(
+              matcher,
+              -> { "Ruby generated by RuboCop is different from expected. #{matcher.failure_message}\n#{format_lints}" }
+            )
+          end
+
+          raise exception_while_running if exception_while_running
+
+          matcher = eq(end_haml)
+          document.source.should(
+            matcher,
+            -> { "Final HAML is different from expected. #{matcher.failure_message}\n#{format_lints}" }
+          )
+
+          if subject.last_extracted_source && start_ruby.strip != 'SKIP'
+            subject.last_extracted_source.source_map.should == source_map
+          end
+
+          haml_different = start_haml != end_haml
+          document.source_was_changed.should == haml_different
+        end
+
+        def format_lints(lints = subject.lints)
+          lints.map { |lint| "#{lint.line}:#{lint.message}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/haml_lint/spec.rb

@@ -2,4 +2,5 @@
 
 require 'haml_lint/spec/normalize_indent'
 require 'haml_lint/spec/shared_linter_context'
+require 'haml_lint/spec/shared_rubocop_autocorrect_context'
 require 'haml_lint/spec/matchers/report_lint'

data/lib/haml_lint/tree/filter_node.rb

@@ -7,5 +7,15 @@ module HamlLint::Tree
     def filter_type
       @value[:name]
     end
+
+    def text
+      # Seems HAML strips the starting blank lines... without them, line numbers become offset,
+      # breaking the source_map and auto-correct
+
+      nb_blank_lines = 0
+      nb_blank_lines += 1 while @document.source_lines[line + nb_blank_lines]&.empty?
+
+      "#{"\n" * nb_blank_lines}#{super}"
+    end
   end
 end

data/lib/haml_lint/tree/node.rb

@@ -104,8 +104,13 @@ module HamlLint::Tree
     def line_numbers
       return (line..line) unless @value && text
 
-      end_line = line + lines.count
-      end_line = nontrivial_end_line if line == end_line && children.empty?
+      end_line = if !lines.empty?
+                   line + lines.count - 1
+                 elsif children.empty?
+                   nontrivial_end_line
+                 else
+                   line
+                 end
 
       (line..end_line)
     end
@@ -155,6 +160,10 @@ module HamlLint::Tree
       @value[:text].to_s
     end
 
+    def keyword
+      @value[:keyword]
+    end
+
     private
 
     # Discovers the end line of the node when there are no lines.
@@ -164,7 +173,7 @@ module HamlLint::Tree
       if successor
         successor.line_numbers.begin - 1
       else
-        @document.source_lines.count
+        @document.last_non_empty_line
       end
     end
 
@@ -212,7 +221,7 @@ module HamlLint::Tree
       # @param node [HamlLint::Tree::Node]
       # @return [Array<HamlLint::Tree::Node>]
       def subsequents(node)
-        siblings[(position(node) + 1)..-1]
+        siblings[(position(node) + 1)..]
       end
 
       private

data/lib/haml_lint/tree/script_node.rb

@@ -9,7 +9,13 @@ module HamlLint::Tree
     #
     # @return [ParsedRuby] syntax tree in the form returned by Parser gem
     def parsed_script
-      HamlLint::ParsedRuby.new(HamlLint::RubyParser.new.parse(script))
+      statement =
+        if children.empty?
+          script
+        else
+          "#{script}#{@value[:keyword] == 'case' ? ';when 0;end' : ';end'}"
+        end
+      HamlLint::ParsedRuby.new(HamlLint::RubyParser.new.parse(statement))
     end
 
     # Returns the source for the script following the `-` marker.

data/lib/haml_lint/tree/silent_script_node.rb

@@ -8,7 +8,22 @@ module HamlLint::Tree
     #
     # @return [ParsedRuby] syntax tree in the form returned by Parser gem
     def parsed_script
-      HamlLint::ParsedRuby.new(HamlLint::RubyParser.new.parse(script))
+      statement =
+        case keyword = @value[:keyword]
+        when 'else', 'elsif'
+          'if 0;' + script + ';end'
+        when 'when'
+          'case;' + script + ';end'
+        when 'rescue', 'ensure'
+          'begin;' + script + ';end'
+        else
+          if children.empty?
+            script
+          else
+            "#{script}#{keyword == 'case' ? ';when 0;end' : ';end'}"
+          end
+        end
+      HamlLint::ParsedRuby.new(HamlLint::RubyParser.new.parse(statement))
     end
 
     # Returns the source for the script following the `-` marker.

data/lib/haml_lint/tree/tag_node.rb

@@ -2,7 +2,7 @@
 
 module HamlLint::Tree
   # Represents a tag node in a HAML document.
-  class TagNode < Node # rubocop:disable Metrics/ClassLength
+  class TagNode < Node
     # Computed set of attribute hashes code.
     #
     # This is a combination of all dynamically calculated attributes from the
@@ -49,9 +49,7 @@ module HamlLint::Tree
     #   dot removed
     def static_classes
       @static_classes ||=
-        begin
-          static_attributes_source.scan(/\.([-:\w]+)/)
-        end
+        static_attributes_source.scan(/\.([-:\w]+)/)
     end
 
     # List of ids statically defined for this tag.
@@ -63,9 +61,7 @@ module HamlLint::Tree
     #   removed
     def static_ids
       @static_ids ||=
-        begin
-          static_attributes_source.scan(/#([-:\w]+)/)
-        end
+        static_attributes_source.scan(/#([-:\w]+)/)
     end
 
     # Static element attributes defined after the tag name.
@@ -101,7 +97,7 @@ module HamlLint::Tree
       @attributes_source ||=
         begin
           _explicit_tag, static_attrs, rest =
-            source_code.scan(/\A\s*(%[-:\w]+)?([-:\w\.\#]*)(.*)/m)[0]
+            source_code.scan(/\A\s*(%[-:\w]+)?([-:\w.\#]*)(.*)/m)[0]
 
           attr_types = {
             '{' => [:hash, %w[{ }]],
@@ -220,7 +216,7 @@ module HamlLint::Tree
     #
     # @return [true,false]
     def remove_outer_whitespace?
-      !!@value[:nuke_outer_whitespace] # rubocop:disable Style/DoubleNegation
+      !!@value[:nuke_outer_whitespace]
     end
 
     # Returns the script source that will be evaluated to produce this tag's