haml_lint 0.45.0 → 0.48.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/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/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

data/lib/haml_lint/utils.rb

@@ -4,7 +4,7 @@ require 'pathname'
 
 module HamlLint
   # A miscellaneous set of utility functions.
-  module Utils
+  module Utils # rubocop:disable Metrics/ModuleLength
     module_function
 
     # Returns whether a glob pattern (or any of a list of patterns) matches the
@@ -52,12 +52,21 @@ module HamlLint
     #   the text.
     # @yieldparam interpolated_code [String] code that was interpolated
     # @yieldparam line [Integer] line number code appears on in text
-    def extract_interpolated_values(text)
+    def extract_interpolated_values(text) # rubocop:disable Metrics/AbcSize
       dumped_text = text.dump
-      newline_positions = extract_substring_positions(dumped_text, '\\\n')
+
+      # Basically, match pairs of '\' and '\ followed by the letter 'n'
+      quoted_regex_s = "(#{Regexp.quote('\\\\')}|#{Regexp.quote('\\n')})"
+      newline_positions = extract_substring_positions(dumped_text, quoted_regex_s)
+
+      # Filter the matches to only keep those ending in 'n'.
+      # This way, escaped \n will not be considered
+      newline_positions.select! do |pos|
+        dumped_text[pos - 1] == 'n'
+      end
 
       Haml::Util.handle_interpolation(dumped_text) do |scan|
-        line = (newline_positions.find_index { |marker| scan.pos <= marker } ||
+        line = (newline_positions.find_index { |marker| scan.charpos <= marker } ||
                 newline_positions.size) + 1
 
         escape_count = (scan[2].size - 1) / 2
@@ -70,6 +79,41 @@ module HamlLint
       end
     end
 
+    def handle_interpolation_with_indexes(text)
+      newline_indexes = extract_substring_positions(text, "\n")
+
+      handle_interpolation_with_newline(text) do |scan|
+        line_index = newline_indexes.find_index { |index| scan.charpos <= index }
+        line_index ||= newline_indexes.size
+
+        line_start_char_index = if line_index == 0
+                                  0
+                                else
+                                  newline_indexes[line_index - 1]
+                                end
+
+        char_index = scan.charpos - line_start_char_index
+
+        yield scan, line_index, char_index
+      end
+    end
+
+    if Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5')
+      # Same as Haml::Util.handle_interpolation, but enables multiline mode on the regex
+      def handle_interpolation_with_newline(str)
+        scan = StringScanner.new(str)
+        yield scan while scan.scan(/(.*?)(\\*)#([{@$])/m)
+        scan.rest
+      end
+    else
+      # Same as Haml::Util.handle_interpolation, but enables multiline mode on the regex
+      def handle_interpolation_with_newline(str)
+        scan = StringScanner.new(str)
+        yield scan while scan.scan(/(.*?)(\\*)\#\{/m)
+        scan.rest
+      end
+    end
+
     # Returns indexes of all occurrences of a substring within a string.
     #
     # Note, this will not return overlaping substrings, so searching for "aa"
@@ -81,7 +125,7 @@ module HamlLint
     def extract_substring_positions(text, substr)
       positions = []
       scanner = StringScanner.new(text)
-      positions << scanner.pos while scanner.scan(/(.*?)#{substr}/)
+      positions << scanner.charpos while scanner.scan(/(.*?)#{substr}/)
       positions
     end
 
@@ -136,6 +180,22 @@ module HamlLint
       count
     end
 
+    # Process ERB, providing some values for for versions to it
+    #
+    # @param content [String] the (usually yaml) content to process
+    # @return [String]
+    def process_erb(content)
+      # Variables for use in the ERB's post-processing
+      rubocop_version = HamlLint::VersionComparer.for_rubocop
+
+      ERB.new(content).result(binding)
+    end
+
+    def insert_after_indentation(code, insert)
+      index = code.index(/\S/)
+      "#{code[0...index]}#{insert}#{code[index..]}"
+    end
+
     # Calls a block of code with a modified set of environment variables,
     # restoring them once the code has executed.
     #
@@ -151,5 +211,75 @@ module HamlLint
     ensure
       old_env.each { |var, value| ENV[var.to_s] = value }
     end
+
+    def indent(string, nb_indent)
+      if nb_indent < 0
+        string.gsub(/^ {1,#{-nb_indent}}/, '')
+      else
+        string.gsub(/^/, ' ' * nb_indent)
+      end
+    end
+
+    def map_subset!(array, range, &block)
+      subset = array[range]
+      return if subset.nil? || subset.empty?
+
+      array[range] = subset.map(&block)
+    end
+
+    def map_after_first!(array, &block)
+      map_subset!(array, 1..-1, &block)
+    end
+
+    # Returns true if line is only whitespace.
+    # Note, this is not like blank? is rails. For nil, this returns false.
+    def is_blank_line?(line)
+      line && line.index(/\S/).nil?
+    end
+
+    def check_error_when_compiling_haml(haml_string)
+      begin
+        ruby_code = ::HamlLint::Adapter.detect_class.new(haml_string).precompile
+      rescue StandardError => e
+        return e
+      end
+      eval("BEGIN {return nil}; #{ruby_code}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+      # The eval will return nil
+    rescue ::SyntaxError
+      $!
+    end
+
+    # Overrides the global stdin, stdout and stderr while within the block, to
+    # push a string in stdin, and capture both stdout and stderr which are returned.
+    #
+    # @param stdin_str [String] the string to push in as stdin
+    # @param _block [Block] the block to perform with the overridden std streams
+    # @return [String, String]
+    def with_captured_streams(stdin_str, &_block)
+      original_stdin = $stdin
+      # The dup is needed so that stdin_data isn't altered (encoding-wise at least)
+      $stdin = StringIO.new(stdin_str.dup)
+      begin
+        original_stdout = $stdout
+        $stdout = StringIO.new
+        begin
+          original_stderr = $stderr
+          $stderr = StringIO.new
+          yield
+          [$stdout.string, $stderr.string]
+        ensure
+          $stderr = original_stderr
+        end
+      ensure
+        $stdout = original_stdout
+      end
+    ensure
+      $stdin = original_stdin
+    end
+
+    def regexp_for_parts(parts, join_regexp)
+      regexp_code = parts.map { |c| Regexp.quote(c) }.join(join_regexp)
+      Regexp.new(regexp_code)
+    end
   end
 end

data/lib/haml_lint/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module HamlLint
-  VERSION = '0.45.0'
+  VERSION = '0.48.0'
 end

data/lib/haml_lint/version_comparer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module HamlLint
+  # A simple wrapper around Gem::Version to allow comparison with String instances
+  # This makes code shorter in some places
+  class VersionComparer
+    def initialize(version)
+      @version = Gem::Version.new(version)
+    end
+
+    include Comparable
+    def <=>(other)
+      @version <=> Gem::Version.new(other)
+    end
+
+    # Shortcut to create a version comparer for the current RuboCop's version
+    def self.for_rubocop
+      new(RuboCop::Version::STRING)
+    end
+
+    def self.for_haml
+      new(Haml::VERSION)
+    end
+  end
+end