haml_lint 0.44.0 → 0.46.0

data/lib/haml_lint/spec/shared_rubocop_autocorrect_context.rb

@@ -0,0 +1,143 @@
+# 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
+
+        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
+          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,70 @@ 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
   end
 end

data/lib/haml_lint/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module HamlLint
-  VERSION = '0.44.0'
+  VERSION = '0.46.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

data/lib/haml_lint.rb

@@ -21,8 +21,14 @@ require 'haml_lint/file_finder'
 require 'haml_lint/runner'
 require 'haml_lint/utils'
 require 'haml_lint/version'
+require 'haml_lint/version_comparer'
 require 'haml_lint/severity'
 
+# Lead all extensions to external source code
+Dir[File.expand_path('haml_lint/extensions/*.rb', File.dirname(__FILE__))].sort.each do |file|
+  require file
+end
+
 # Load all parse tree node classes
 require 'haml_lint/tree/node'
 require 'haml_lint/node_transformer'
@@ -39,3 +45,9 @@ end
 Dir[File.expand_path('haml_lint/reporter/*.rb', File.dirname(__FILE__))].sort.each do |file|
   require file
 end
+
+# Load all the chunks for RubyExtraction
+require 'haml_lint/ruby_extraction/base_chunk'
+Dir[File.expand_path('haml_lint/ruby_extraction/*.rb', File.dirname(__FILE__))].sort.each do |file|
+  require file
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: haml_lint
 version: !ruby/object:Gem::Version
-  version: 0.44.0
+  version: 0.46.0
 platform: ruby
 authors:
 - Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-27 00:00:00.000000000 Z
+date: 2023-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.50.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.50.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: sysexits
   requirement: !ruby/object:Gem::Requirement
@@ -96,6 +96,7 @@ extra_rdoc_files: []
 files:
 - bin/haml-lint
 - config/default.yml
+- config/forced_rubocop_config.yml
 - lib/haml_lint.rb
 - lib/haml_lint/adapter.rb
 - lib/haml_lint/adapter/haml_4.rb
@@ -109,6 +110,7 @@ files:
 - lib/haml_lint/directive.rb
 - lib/haml_lint/document.rb
 - lib/haml_lint/exceptions.rb
+- lib/haml_lint/extensions/haml_util_unescape_interpolation_tracking.rb
 - lib/haml_lint/file_finder.rb
 - lib/haml_lint/haml_visitor.rb
 - lib/haml_lint/lint.rb
@@ -132,6 +134,7 @@ files:
 - lib/haml_lint/linter/line_length.rb
 - lib/haml_lint/linter/multiline_pipe.rb
 - lib/haml_lint/linter/multiline_script.rb
+- lib/haml_lint/linter/no_placeholders.rb
 - lib/haml_lint/linter/object_reference_attributes.rb
 - lib/haml_lint/linter/repeated_id.rb
 - lib/haml_lint/linter/rubocop.rb
@@ -162,6 +165,20 @@ files:
 - lib/haml_lint/reporter/offense_count_reporter.rb
 - lib/haml_lint/reporter/progress_reporter.rb
 - lib/haml_lint/reporter/utils.rb
+- lib/haml_lint/ruby_extraction/ad_hoc_chunk.rb
+- lib/haml_lint/ruby_extraction/base_chunk.rb
+- lib/haml_lint/ruby_extraction/chunk_extractor.rb
+- lib/haml_lint/ruby_extraction/coordinator.rb
+- lib/haml_lint/ruby_extraction/haml_comment_chunk.rb
+- lib/haml_lint/ruby_extraction/implicit_end_chunk.rb
+- lib/haml_lint/ruby_extraction/interpolation_chunk.rb
+- lib/haml_lint/ruby_extraction/non_ruby_filter_chunk.rb
+- lib/haml_lint/ruby_extraction/placeholder_marker_chunk.rb
+- lib/haml_lint/ruby_extraction/ruby_filter_chunk.rb
+- lib/haml_lint/ruby_extraction/ruby_source.rb
+- lib/haml_lint/ruby_extraction/script_chunk.rb
+- lib/haml_lint/ruby_extraction/tag_attributes_chunk.rb
+- lib/haml_lint/ruby_extraction/tag_script_chunk.rb
 - lib/haml_lint/ruby_extractor.rb
 - lib/haml_lint/ruby_parser.rb
 - lib/haml_lint/runner.rb
@@ -170,6 +187,7 @@ files:
 - lib/haml_lint/spec/matchers/report_lint.rb
 - lib/haml_lint/spec/normalize_indent.rb
 - lib/haml_lint/spec/shared_linter_context.rb
+- lib/haml_lint/spec/shared_rubocop_autocorrect_context.rb
 - lib/haml_lint/tree/comment_node.rb
 - lib/haml_lint/tree/doctype_node.rb
 - lib/haml_lint/tree/filter_node.rb
@@ -183,6 +201,7 @@ files:
 - lib/haml_lint/tree/tag_node.rb
 - lib/haml_lint/utils.rb
 - lib/haml_lint/version.rb
+- lib/haml_lint/version_comparer.rb
 homepage: https://github.com/sds/haml-lint
 licenses:
 - MIT
@@ -195,14 +214,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: HAML lint tool