haml_lint 0.47.0 → 0.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7a818da3ed1d58db0ad35b864c6c90d8036173109f6609da452da8b496dd1d5
-  data.tar.gz: ca045650d3373d2fa48d840c684c14b3d46a497f39e91eb9058b1827f3bd74b7
+  metadata.gz: 93d2cec8a3ce45f370d5e8d055ed8f9dc5a988e2c56e8e145f50710f04f40a3f
+  data.tar.gz: 59a2d93bd2ab520c4fb1288cf85f784d3d20955293b6167f046bffba3f198cac
 SHA512:
-  metadata.gz: 0e2d83720d795e4589d534087c4db2be681eeae95cecda6432917345dea5e4c59e8ba7d65633fb2d4cd0ea86eafc0ea89b8fc51f994cc0b7973a50b0fa0a0abd
-  data.tar.gz: 11fc0ea04b7dae506bb0e264d204bdcdcaa96a65230ade8416ae56094a46f95deb3a1006200919804769dcc1c7adf7ab407bbfdf863355248eea9b0e7858308a
+  metadata.gz: be4b59ae43a2cab51fd4148e843177b939da14ee7b0dc40a8ed0d9dd7bbcd12d39d674c1d9c7f19f0a524d912e27fc82b882f6412083eda143c5cf60e218c397
+  data.tar.gz: 28075057ee4c955a4966d2561ff77680b9d90c24e647dc83386dab4ebfabc404cbcb22913836f987896cc506244a4f612f74e131d8838c91f1e0db027d0f8cdd

data/lib/haml_lint/linter/repeated_id.rb

@@ -8,13 +8,14 @@ module HamlLint
     MESSAGE_FORMAT = %{Do not repeat id "#%s" on the page}
 
     def visit_root(_node)
-      @id_map = Hash.new { |hash, key| hash[key] = [] }
+      @id_map = {}
     end
 
     def visit_tag(node)
       id = node.tag_id
       return unless id && !id.empty?
 
+      id_map[id] ||= []
       nodes = (id_map[id] << node)
       case nodes.size
       when 1 then nil

data/lib/haml_lint/linter/rubocop.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'haml_lint/ruby_extractor'
 require 'rubocop'
 require 'tempfile'
 

data/lib/haml_lint/ruby_extraction/chunk_extractor.rb

@@ -11,6 +11,12 @@ module HamlLint::RubyExtraction
 
     attr_reader :script_output_prefix
 
+    HAML_PARSER_INSTANCE = if Haml::VERSION >= '5.0.0'
+                             ::Haml::Parser.new({})
+                           else
+                             ::Haml::Parser.new('', {})
+                           end
+
     def initialize(document, script_output_prefix:)
       @document = document
       @script_output_prefix = script_output_prefix
@@ -19,13 +25,18 @@ module HamlLint::RubyExtraction
     def extract
       raise 'Already extracted' if @ruby_chunks
 
-      @ruby_chunks = []
-      @original_haml_lines = @document.source_lines
+      prepare_extract
 
       visit(@document.tree)
       @ruby_chunks
     end
 
+    # Useful for tests
+    def prepare_extract
+      @ruby_chunks = []
+      @original_haml_lines = @document.source_lines
+    end
+
     def visit_root(_node)
       yield # Collect lines of code from children
     end
@@ -71,33 +82,44 @@ module HamlLint::RubyExtraction
     # Visiting comments which are output to HTML. Lines looking like
     #   `  / This will be in the HTML source!`
     def visit_comment(node)
-      lines = raw_lines_of_interest(node.line - 1)
-      indent = lines.first.index(/\S/)
+      line = @original_haml_lines[node.line - 1]
+      indent = line.index(/\S/)
       @ruby_chunks << PlaceholderMarkerChunk.new(node, 'comment', indent: indent)
     end
 
     # Visit a script which outputs. Lines looking like `  = foo`
     def visit_script(node, &block)
-      lines = raw_lines_of_interest(node.line - 1)
+      raw_first_line = @original_haml_lines[node.line - 1]
+
+      # ==, !, !==, &, &== means interpolation (was needed before HAML 2.2... it's still supported)
+      # =, !=, &= mean actual ruby code is coming
+      # Anything else is interpolation
+      # The regex lists the case for Ruby Code. The 3 cases and making sure they are not followed by another = sign
 
-      if lines.first !~ /\A\s*[-=]/
+      match = raw_first_line.match(/\A\s*(=|!=|&=)(?!=)/)
+      unless match
         # The line doesn't start with a - or a =, this is actually a "plain"
         # that contains interpolation.
-        indent = lines.first.index(/\S/)
+        indent = raw_first_line.index(/\S/)
         @ruby_chunks << PlaceholderMarkerChunk.new(node, 'interpolation', indent: indent)
-        add_interpolation_chunks(node, lines.first, node.line - 1, indent: indent)
+        add_interpolation_chunks(node, raw_first_line, node.line - 1, indent: indent)
         return
       end
 
-      lines[0] = lines[0].sub(/(=[ \t]?)/, '')
+      script_prefix = match[1]
+      _first_line_offset, lines = extract_raw_ruby_lines(node.script, node.line - 1)
+      # We want the actual indentation and prefix for the first line
+      first_line = lines[0] = @original_haml_lines[node.line - 1].rstrip
+      process_multiline!(first_line)
+
+      lines[0] = lines[0].sub(/(#{script_prefix}[ \t]?)/, '')
       line_indentation = Regexp.last_match(1).size
 
       raw_code = lines.join("\n")
 
       if lines[0][/\S/] == '#'
-        # a script that only constains a comment... needs special handling
-        comment_index = lines[0].index(/\S/)
-        lines[0].insert(comment_index + 1, " #{script_output_prefix.rstrip}")
+        # a "=" script that only contains a comment... No need for the "HL.out = " prefix,
+        # just treat it as comment which will turn into a "-" comment
       else
         lines[0] = HamlLint::Utils.insert_after_indentation(lines[0], script_output_prefix)
       end
@@ -124,14 +146,25 @@ module HamlLint::RubyExtraction
         # By forcing this to start a chunk, there will be extra placeholders which
         # blocks rubocop from merging the lines.
         must_start_chunk = true
+      elsif script_prefix != '='
+        # In the few cases where &= and != are used to start the script,
+        # We need to remember and put it back in the final HAML. Fusing scripts together
+        # would make that basically impossible. Instead, a script has a "first_output_prefix"
+        # field for this specific case
+        must_start_chunk = true
       end
 
-      finish_visit_any_script(node, lines, raw_code: raw_code, must_start_chunk: must_start_chunk, &block)
+      finish_visit_any_script(node, lines, raw_code: raw_code, must_start_chunk: must_start_chunk,
+                              first_output_prefix: script_prefix, &block)
     end
 
     # Visit a script which doesn't output. Lines looking like `  - foo`
     def visit_silent_script(node, &block)
-      lines = raw_lines_of_interest(node.line - 1)
+      _first_line_offset, lines = extract_raw_ruby_lines(node.script, node.line - 1)
+      # We want the actual indentation and prefix for the first line
+      first_line = lines[0] = @original_haml_lines[node.line - 1].rstrip
+      process_multiline!(first_line)
+
       lines[0] = lines[0].sub(/(-[ \t]?)/, '')
       nb_to_deindent = Regexp.last_match(1).size
 
@@ -145,7 +178,7 @@ module HamlLint::RubyExtraction
     # Code common to both silent and outputting scripts
     #
     # raw_code is the code before we do transformations, such as adding the `HL.out = `
-    def finish_visit_any_script(node, lines, raw_code: nil, must_start_chunk: false)
+    def finish_visit_any_script(node, lines, raw_code: nil, must_start_chunk: false, first_output_prefix: '=')
       raw_code ||= lines.join("\n")
       start_nesting = self.class.start_nesting_after?(raw_code)
 
@@ -158,7 +191,8 @@ module HamlLint::RubyExtraction
       @ruby_chunks << ScriptChunk.new(node, lines,
                                       end_marker_indent: indent_after,
                                       must_start_chunk: must_start_chunk,
-                                      previous_chunk: @ruby_chunks.last)
+                                      previous_chunk: @ruby_chunks.last,
+                                      first_output_haml_prefix: first_output_prefix)
 
       yield
 
@@ -184,26 +218,32 @@ module HamlLint::RubyExtraction
     def visit_tag(node)
       indent = @original_haml_lines[node.line - 1].index(/\S/)
 
-      has_children = !node.children.empty?
-      if has_children
-        # We don't want to use a block because assignments in a block are local to that block,
-        # so the semantics of the extracted ruby would be different from the one generated by
-        # Haml. Those differences can make some cops, such as UselessAssignment, have false
-        # positives
-        code = 'begin'
-        @ruby_chunks << AdHocChunk.new(node,
-                                       [' ' * indent + code])
-        indent += 2
-      end
+      # We don't want to use a block because assignments in a block are local to that block,
+      # so the semantics of the extracted ruby would be different from the one generated by
+      # Haml. Those differences can make some cops, such as UselessAssignment, have false
+      # positives
+      code = 'begin'
+      @ruby_chunks << AdHocChunk.new(node,
+                                     [' ' * indent + code])
+      indent += 2
 
-      @ruby_chunks << PlaceholderMarkerChunk.new(node, 'tag', indent: indent)
+      tag_chunk = PlaceholderMarkerChunk.new(node, 'tag', indent: indent)
+      @ruby_chunks << tag_chunk
 
       current_line_index = visit_tag_attributes(node, indent: indent)
       visit_tag_script(node, line_index: current_line_index, indent: indent)
 
-      if has_children
-        yield
-        indent -= 2
+      yield
+
+      indent -= 2
+
+      if @ruby_chunks.last.equal?(tag_chunk)
+        # So there is nothing going "in" the tag, remove the wrapping "begin" and replace the PlaceholderMarkerChunk
+        # by one less indented
+        @ruby_chunks.pop
+        @ruby_chunks.pop
+        @ruby_chunks << PlaceholderMarkerChunk.new(node, 'tag', indent: indent)
+      else
         @ruby_chunks << AdHocChunk.new(node,
                                        [' ' * indent + 'ensure', ' ' * indent + '  HL.noop', ' ' * indent + 'end'],
                                        haml_line_index: @ruby_chunks.last.haml_end_line_index)
@@ -222,11 +262,16 @@ module HamlLint::RubyExtraction
       attributes_code = additional_attributes.first
       if !attributes_code && node.hash_attributes? && node.dynamic_attributes_sources.empty?
         # No idea why .foo{:bar => 123} doesn't get here, but .foo{:bar => '123'} does...
-        # The code we get for the later is {:bar => '123'}.
+        # The code we get for the latter is {:bar => '123'}.
         # We normalize it by removing the { } so that it matches wha we normally get
         attributes_code = node.dynamic_attributes_source[:hash][1...-1]
       end
 
+      if attributes_code&.start_with?('{')
+        # Looks like the .foo(bar = 123) case. Ignoring.
+        attributes_code = nil
+      end
+
       return final_line_index unless attributes_code
       # Attributes have different ways to be given to us:
       #   .foo{bar: 123} => "bar: 123"
@@ -235,14 +280,13 @@ module HamlLint::RubyExtraction
       #   .foo(bar = 123) => '{"bar" => 123,}'
       #   .foo{html_attrs('fr-fr')} => html_attrs('fr-fr')
       #
-      # The (bar = 123) case is extra painful to autocorrect (so is ignored).
+      # The (bar = 123) case is extra painful to autocorrect (so is ignored up there).
       # #raw_ruby_from_haml  will "detect" this case by not finding the code.
       #
       # We wrap the result in a method to have a valid syntax for all 3 ways
       # without having to differentiate them.
-      first_line_offset, raw_attributes_lines = raw_ruby_lines_from_haml(attributes_code,
-                                                                         node.line - 1)
-
+      first_line_offset, raw_attributes_lines = extract_raw_tag_attributes_ruby_lines(attributes_code,
+                                                                                      node.line - 1)
       return final_line_index unless raw_attributes_lines
 
       final_line_index += raw_attributes_lines.size - 1
@@ -276,7 +320,7 @@ module HamlLint::RubyExtraction
       # We ignore scripts which are just a comment
       return if node.script[/\S/] == '#'
 
-      first_line_offset, script_lines = raw_ruby_lines_from_haml(node.script, line_index)
+      first_line_offset, script_lines = extract_raw_ruby_lines(node.script, line_index)
 
       if script_lines.nil?
         # This is a string with interpolation after a tag
@@ -380,52 +424,87 @@ module HamlLint::RubyExtraction
       end
     end
 
+    def process_multiline!(line)
+      if HAML_PARSER_INSTANCE.send(:is_multiline?, line)
+        line.chop!.rstrip!
+        true
+      else
+        false
+      end
+    end
+
     # Returns the raw lines from the haml for the given index.
     # Multiple lines are returned when a line ends with a comma as that is the only
     # time HAMLs allows Ruby lines to be split.
-    def raw_lines_of_interest(first_line_index)
-      line_index = first_line_index
-      lines_of_interest = [@original_haml_lines[line_index]]
-
-      while @original_haml_lines[line_index].rstrip.end_with?(',')
-        line_index += 1
-        lines_of_interest << @original_haml_lines[line_index]
-      end
-
-      lines_of_interest
-    end
 
     # Haml's line-splitting rules (allowed after comma in scripts and attributes) are handled
     # at the parser level, so Haml doesn't provide the code as it is actually formatted in the Haml
     # file. #raw_ruby_from_haml extracts the ruby code as it is exactly in the Haml file.
     # The first and last lines may not be the complete lines from the Haml, only the Ruby parts
     # and the indentation between the first and last list.
-    def raw_ruby_lines_from_haml(code, first_line_index)
-      stripped_code = code.strip
-      return if stripped_code.empty?
 
-      lines_of_interest = raw_lines_of_interest(first_line_index)
+    # HAML transforms the ruby code in many ways as it parses a document. Often removing lines and/or
+    # indentation. This is quite annoying for us since we want the exact layout of the code to analyze it.
+    #
+    # This function receives the code as haml provides it and the line where it starts. It returns
+    # the actual code as it is in the haml file, keeping breaks and indentation for the following lines.
+    # In addition, the start position of the code in the first line.
+    #
+    # The rules for handling multiline code in HAML are as follow:
+    # * if the line being processed ends with a space and a pipe, then append to the line (without
+    #   newlines) every following lines that also end with a space and a pipe. This means the last line of
+    #   the "block" also needs a pipe at the end.
+    # * after processing the pipes, when dealing with ruby code (and not in tag attributes' hash), if the line
+    #   (which maybe span across multiple lines) ends with a comma, add the next line to the current piece of code.
+    #
+    # @return [first_line_offset, ruby_lines]
+    def extract_raw_ruby_lines(haml_processed_ruby_code, first_line_index)
+      haml_processed_ruby_code = haml_processed_ruby_code.strip
+      first_line = @original_haml_lines[first_line_index]
 
-      if lines_of_interest.size == 1
-        index = lines_of_interest.first.index(stripped_code)
-        if lines_of_interest.first.include?(stripped_code)
-          return [index, [stripped_code]]
-        else
-          # Sometimes, the code just isn't in the Haml when Haml does transformations to it
-          return
-        end
+      char_index = first_line.index(haml_processed_ruby_code)
+
+      if char_index
+        return [char_index, [haml_processed_ruby_code]]
+      end
+
+      cur_line_index = first_line_index
+      cur_line = first_line.rstrip
+      lines = []
+
+      # The pipes must also be on the last line of the multi-line section
+      while cur_line && process_multiline!(cur_line)
+        lines << cur_line
+        cur_line_index += 1
+        cur_line = @original_haml_lines[cur_line_index].rstrip
+      end
+
+      if lines.empty?
+        lines << cur_line
+      else
+        # The pipes must also be on the last line of the multi-line section. So cur_line is not the next line.
+        # We want to go back to check for commas
+        cur_line_index -= 1
+        cur_line = lines.last
       end
 
-      raw_haml = lines_of_interest.join("\n")
+      while HAML_PARSER_INSTANCE.send(:is_ruby_multiline?, cur_line)
+        cur_line_index += 1
+        cur_line = @original_haml_lines[cur_line_index].rstrip
+        lines << cur_line
+      end
+
+      joined_lines = lines.join("\n")
+
+      if haml_processed_ruby_code.include?("\n")
+        haml_processed_ruby_code = haml_processed_ruby_code.gsub("\n", ' ')
+      end
 
-      # Need the gsub because while multiline scripts are turned into a single line,
-      # by haml, multiline tag attributes are not.
-      code_parts = stripped_code.gsub("\n", ' ').split(/,\s*/)
+      haml_processed_ruby_code.split(/[, ]/)
 
-      regexp_code = code_parts.map { |c| Regexp.quote(c) }.join(',\\s*')
-      regexp = Regexp.new(regexp_code)
+      regexp = HamlLint::Utils.regexp_for_parts(haml_processed_ruby_code.split(/,\s*|\s+/), '(?:,\\s*|\\s+)')
 
-      match = raw_haml.match(regexp)
+      match = joined_lines.match(regexp)
       # This can happen when pipes are used as marker for multiline parts, and when tag attributes change lines
       # without ending by a comma. This is quite a can of worm and is probably not too frequent, so for now,
       # these cases are not supported.
@@ -438,6 +517,48 @@ module HamlLint::RubyExtraction
       [first_line_offset, ruby_lines]
     end
 
+    # Tag attributes actually handle multiline differently than scripts.
+    # The basic system basically keeps considering more lines until it meets the closing braces, but still
+    # processes pipes too (same as extract_raw_ruby_lines).
+    def extract_raw_tag_attributes_ruby_lines(haml_processed_ruby_code, first_line_index)
+      haml_processed_ruby_code = haml_processed_ruby_code.strip
+      first_line = @original_haml_lines[first_line_index]
+
+      char_index = first_line.index(haml_processed_ruby_code)
+
+      if char_index
+        return [char_index, [haml_processed_ruby_code]]
+      end
+
+      min_non_white_chars_to_add = haml_processed_ruby_code.scan(/\S/).size
+
+      regexp = HamlLint::Utils.regexp_for_parts(haml_processed_ruby_code.split(/\s+/), '\\s+')
+
+      joined_lines = first_line.rstrip
+      process_multiline!(joined_lines)
+
+      cur_line_index = first_line_index + 1
+      while @original_haml_lines[cur_line_index] && min_non_white_chars_to_add > 0
+        new_line = @original_haml_lines[cur_line_index].rstrip
+        process_multiline!(new_line)
+
+        min_non_white_chars_to_add -= new_line.scan(/\S/).size
+        joined_lines << "\n"
+        joined_lines << new_line
+        cur_line_index += 1
+      end
+
+      match = joined_lines.match(regexp)
+
+      return if match.nil?
+
+      first_line_offset = match.begin(0)
+      raw_ruby = match[0]
+      ruby_lines = raw_ruby.split("\n")
+
+      [first_line_offset, ruby_lines]
+    end
+
     def wrap_lines(lines, wrap_depth)
       lines = lines.dup
       wrapping_prefix = 'W' * (wrap_depth - 1) + '('

data/lib/haml_lint/ruby_extraction/haml_comment_chunk.rb

@@ -15,26 +15,6 @@ module HamlLint::RubyExtraction
       HamlCommentChunk.new(node, @ruby_lines + following_chunk.ruby_lines, end_marker_indent: end_marker_indent)
     end
 
-    def fuse_script_chunk(following_chunk)
-      return if following_chunk.end_marker_indent.nil?
-      return if following_chunk.must_start_chunk
-
-      nb_blank_lines_between = following_chunk.haml_line_index - haml_line_index - nb_haml_lines
-      blank_lines = nb_blank_lines_between > 0 ? [''] * nb_blank_lines_between : []
-      new_lines = @ruby_lines + blank_lines + following_chunk.ruby_lines
-
-      source_map_skips = @skip_line_indexes_in_source_map
-      source_map_skips.concat(following_chunk.skip_line_indexes_in_source_map
-                                .map { |i| i + @ruby_lines.size })
-
-      ScriptChunk.new(node,
-                      new_lines,
-                      haml_line_index: haml_line_index,
-                      skip_line_indexes_in_source_map: source_map_skips,
-                      end_marker_indent: following_chunk.end_marker_indent,
-                      previous_chunk: previous_chunk)
-    end
-
     def transfer_correction_logic(_coordinator, to_ruby_lines, haml_lines)
       if to_ruby_lines.empty?
         haml_lines.slice!(@haml_line_index..haml_end_line_index)

data/lib/haml_lint/ruby_extraction/script_chunk.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+require 'ripper'
+
 module HamlLint::RubyExtraction
   # Chunk for handling outputting and silent scripts, so `  = foo` and `  - bar`
   # Does NOT handle a script beside a tag (ex: `%div= spam`)
   class ScriptChunk < BaseChunk
     MID_BLOCK_KEYWORDS = %w[else elsif when rescue ensure].freeze
 
+    # @return [String] The prefix for the first outputting string of this script. (One of = != &=)
+    #   The outputting scripts after the first are always with =
+    attr_reader :first_output_haml_prefix
+
     # @return [Boolean] true if this ScriptChunk must be at the beginning of a chunk.
     #   This blocks this ScriptChunk from being fused to a ScriptChunk that is before it.
     #   Needed to handle some patterns of outputting script.
@@ -19,12 +25,13 @@ module HamlLint::RubyExtraction
     #   our starting marker must be indented.
     attr_reader :previous_chunk
 
-    def initialize(*args, previous_chunk:, must_start_chunk: false,
-                   skip_line_indexes_in_source_map: [], **kwargs)
+    def initialize(*args, previous_chunk:, must_start_chunk: false, # rubocop:disable Metrics/ParameterLists
+                   skip_line_indexes_in_source_map: [], first_output_haml_prefix: '=', **kwargs)
       super(*args, **kwargs)
       @must_start_chunk = must_start_chunk
       @skip_line_indexes_in_source_map = skip_line_indexes_in_source_map
       @previous_chunk = previous_chunk
+      @first_output_haml_prefix = first_output_haml_prefix
     end
 
     def fuse(following_chunk)
@@ -53,7 +60,8 @@ module HamlLint::RubyExtraction
                       haml_line_index: haml_line_index,
                       skip_line_indexes_in_source_map: source_map_skips,
                       end_marker_indent: following_chunk.end_marker_indent,
-                      previous_chunk: previous_chunk)
+                      previous_chunk: previous_chunk,
+                      first_output_haml_prefix: @first_output_haml_prefix)
     end
 
     def fuse_implicit_end(following_chunk)
@@ -70,7 +78,8 @@ module HamlLint::RubyExtraction
                       haml_line_index: haml_line_index,
                       skip_line_indexes_in_source_map: source_map_skips,
                       end_marker_indent: following_chunk.end_marker_indent,
-                      previous_chunk: previous_chunk)
+                      previous_chunk: previous_chunk,
+                      first_output_haml_prefix: @first_output_haml_prefix)
     end
 
     def start_marker_indent
@@ -79,54 +88,157 @@ module HamlLint::RubyExtraction
       [default_indent, previous_chunk&.end_marker_indent || previous_chunk&.start_marker_indent].compact.max
     end
 
-    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines) # rubocop:disable Metrics
+    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines)
+      to_haml_lines = self.class.format_ruby_lines_to_haml_lines(
+        to_ruby_lines,
+        script_output_ruby_prefix: coordinator.script_output_prefix,
+        first_output_haml_prefix: @first_output_haml_prefix
+      )
+
+      haml_lines[@haml_line_index..haml_end_line_index] = to_haml_lines
+    end
+
+    ALLOW_EXPRESSION_AFTER_LINE_ENDING_WITH = %w[else begin ensure].freeze
+
+    def self.format_ruby_lines_to_haml_lines(to_ruby_lines, script_output_ruby_prefix:, first_output_haml_prefix: '=') # rubocop:disable Metrics
       to_ruby_lines.reject! { |l| l.strip == 'end' }
+      return [] if to_ruby_lines.empty?
 
-      output_comment_prefix = ' ' + coordinator.script_output_prefix.rstrip
-      to_ruby_lines.map! do |line|
-        if line.lstrip.start_with?('#' + output_comment_prefix)
-          line = line.dup
-          comment_index = line.index('#')
-          removal_start_index = comment_index + 1
-          removal_end_index = removal_start_index + output_comment_prefix.size
-          line[removal_start_index...removal_end_index] = ''
-          # It will be removed again below, but will know its suposed to be a =
-          line.insert(comment_index, coordinator.script_output_prefix)
-        end
-        line
-      end
+      statement_start_line_indexes = find_statement_start_line_indexes(to_ruby_lines)
 
       continued_line_indent_delta = 2
 
+      cur_line_start_index = nil
+      line_start_indexes_that_need_pipes = []
+      haml_output_prefix = first_output_haml_prefix
       to_haml_lines = to_ruby_lines.map.with_index do |line, i|
         if line !~ /\S/
           # whitespace or empty lines, we don't want any indentation
           ''
-        elsif line_starts_script?(to_ruby_lines, i)
+        elsif statement_start_line_indexes.include?(i)
+          cur_line_start_index = i
           code_start = line.index(/\S/)
-          if line[code_start..].start_with?(coordinator.script_output_prefix)
-            line = line.sub(coordinator.script_output_prefix, '')
-            continued_line_indent_delta = 2 - coordinator.script_output_prefix.size
-            "#{line[0...code_start]}= #{line[code_start..]}"
+          if line[code_start..].start_with?(script_output_ruby_prefix)
+            line = line.sub(script_output_ruby_prefix, '')
+            # The line may have been too indented because of the "HL.out = " prefix
+            continued_line_indent_delta = 2 - script_output_ruby_prefix.size
+            new_line = "#{line[0...code_start]}#{haml_output_prefix} #{line[code_start..]}"
+            haml_output_prefix = '='
+            new_line
           else
             continued_line_indent_delta = 2
             "#{line[0...code_start]}- #{line[code_start..]}"
           end
         else
+          unless to_ruby_lines[i - 1].end_with?(',')
+            line_start_indexes_that_need_pipes << cur_line_start_index
+          end
+
           HamlLint::Utils.indent(line, continued_line_indent_delta)
         end
       end
 
-      haml_lines[@haml_line_index..haml_end_line_index] = to_haml_lines
-    end
+      # Starting from the end because we need to add newlines when 2 groups of lines need pipes, so that they are
+      # separate.
+      line_start_indexes_that_need_pipes.reverse_each do |cur_line_i|
+        loop do
+          cur_line = to_haml_lines[cur_line_i]
+          break if cur_line.nil? || cur_line.empty?
+          to_haml_lines[cur_line_i] = cur_line + ' |'
+          cur_line_i += 1
+
+          break if statement_start_line_indexes.include?(cur_line_i)
+        end
+
+        next_line = to_haml_lines[cur_line_i]
+        if next_line && HamlLint::RubyExtraction::ChunkExtractor::HAML_PARSER_INSTANCE.send(:is_multiline?, next_line)
+          to_haml_lines.insert(cur_line_i, '')
+        end
+      end
 
-    def unfinished_script_line?(lines, line_index)
-      !!lines[line_index][/,[ \t]*\z/]
+      to_haml_lines
     end
 
-    def line_starts_script?(lines, line_index)
-      return true if line_index == 0
-      !unfinished_script_line?(lines, line_index - 1)
+    def self.find_statement_start_line_indexes(to_ruby_lines) # rubocop:disable Metrics
+      if to_ruby_lines.size == 1
+        if to_ruby_lines.first[/\S/]
+          return [0]
+        else
+          return []
+        end
+      end
+      statement_start_line_indexes = [] # 0-indexed
+      allow_expression_after_line_number = 0 # 1-indexed
+      last_do_keyword_line_number = nil # 1-indexed, like Ripper.lex
+
+      to_ruby_string = to_ruby_lines.join("\n")
+      if RUBY_VERSION < '3.1'
+        # Ruby 2.6's Ripper has issues when it encounters a else, when, elsif without a matching if/case before.
+        # It literally stop lexing at that point without any error.
+        # Ex from 2.7.8:
+        #   require 'ripper'
+        #   Ripper.lex("a\nelse\nb")
+        #   #=> [[[1, 0], :on_ident, "a", CMDARG], [[1, 1], :on_nl, "\n", BEG], [[2, 0], :on_kw, "else", BEG]]
+        # So we add enough ifs to last quite a few layer. Hopefully enough for all needs. To clarify, there would need
+        # as many "end" keyword in a single ScriptChunk followed by one of the problematic keyword for the problem
+        # to show up.
+        # Considering that a `end` without anything else on the line is removed from to_ruby_lines before getting here
+        # (in format_ruby_lines_to_haml_lines), 10 ifs should be plenty.
+        to_ruby_string = ('if a;' * 10) + to_ruby_string
+      end
+
+      last_line_number_seen = nil
+      Ripper.lex(to_ruby_string).each do |start_loc, token, str|
+        last_line_number_seen = start_loc[0]
+        if token == :on_nl
+          # :on_nl happens when we have a meaningful line change.
+          allow_expression_after_line_number = start_loc[0]
+          next
+        elsif token == :on_ignored_nl
+          # :on_ignored_nl happens for newlines within an expression, or consecutive newlines..
+          #    and some cases we care about such as a newline after the pipes after arguments of a block
+          if last_do_keyword_line_number == start_loc[0]
+            # When starting a block, Ripper.lex gives :on_ignored_nl
+            allow_expression_after_line_number = start_loc[0]
+          end
+          next
+        end
+
+        if allow_expression_after_line_number && str[/\S/]
+          if allow_expression_after_line_number < start_loc[0]
+            # Ripper.lex returns line numbers 1-indexed, we want 0-indexed
+            statement_start_line_indexes << start_loc[0] - 1
+          end
+          allow_expression_after_line_number = nil
+        end
+
+        if token == :on_comment
+          # :on_comment contain its own newline at the end of the content
+          allow_expression_after_line_number = start_loc[0]
+        elsif token == :on_kw
+          if str == 'do'
+            # Because of the possible arguments for the block, we can't simply set is_between_expressions to true
+            last_do_keyword_line_number = start_loc[0]
+          elsif ALLOW_EXPRESSION_AFTER_LINE_ENDING_WITH.include?(str)
+            allow_expression_after_line_number = start_loc[0]
+          end
+        end
+      end
+
+      # number is 1-indexed, and we want the line after it, so that's great
+      if last_line_number_seen < to_ruby_lines.size && to_ruby_lines[last_line_number_seen..].any? { |l| l[/\S/] }
+        # There are non-empty lines after the last line Ripper showed us, that's a problem!
+        msg = +'It seems Ripper did not properly process some source code. Please make sure you are on the '
+        msg << 'latest Haml-Lint version, then create an issue at '
+        msg << "https://github.com/sds/haml-lint/issues and include the following information:\n"
+        msg << "Ruby version: #{RUBY_VERSION}\n"
+        msg << "Haml-Lint version: #{HamlLint::VERSION}\n"
+        msg << "HAML version: #{Haml::VERSION}\n"
+        msg << "problematic source code:\n```\n#{to_ruby_lines.join("\n")}\n```"
+        raise msg
+      end
+
+      statement_start_line_indexes
     end
   end
 end

data/lib/haml_lint/ruby_extraction/tag_attributes_chunk.rb

@@ -8,19 +8,43 @@ module HamlLint::RubyExtraction
       @indent_to_remove = indent_to_remove
     end
 
-    def transfer_correction_logic(_coordinator, to_ruby_lines, haml_lines)
+    def transfer_correction_logic(_coordinator, to_ruby_lines, haml_lines) # rubocop:disable Metrics
+      return if @ruby_lines == to_ruby_lines
+
       affected_haml_lines = haml_lines[@haml_line_index..haml_end_line_index]
 
       affected_haml = affected_haml_lines.join("\n")
 
       from_ruby = unwrap(@ruby_lines).join("\n")
+
+      if to_ruby_lines.size > 1
+        min_indent = to_ruby_lines.first[/^\s*/]
+        to_ruby_lines.each.with_index do |line, i|
+          next if i == 0
+          next if line.start_with?(min_indent)
+          to_ruby_lines[i] = "#{min_indent}#{line.lstrip}"
+        end
+      end
+
       to_ruby = unwrap(to_ruby_lines).join("\n")
 
       affected_start_index = affected_haml.index(from_ruby)
-      affected_end_index = affected_start_index + from_ruby.size
+      if affected_start_index
+        affected_end_index = affected_start_index + from_ruby.size
+      else
+        regexp = HamlLint::Utils.regexp_for_parts(from_ruby.split("\n"), "(?:\s*\\|?\n)")
+        mo = affected_haml.match(regexp)
+        affected_start_index = mo.begin(0)
+        affected_end_index = mo.end(0)
+      end
+
       affected_haml[affected_start_index...affected_end_index] = to_ruby
 
       haml_lines[@haml_line_index..haml_end_line_index] = affected_haml.split("\n")
+
+      if haml_lines[haml_end_line_index].end_with?(' |')
+        haml_lines[haml_end_line_index].chop!.rstrip!
+      end
     end
 
     def unwrap(lines)

data/lib/haml_lint/utils.rb

@@ -276,5 +276,10 @@ module HamlLint
     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.47.0'
+  VERSION = '0.48.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: haml_lint
 version: !ruby/object:Gem::Version
-  version: 0.47.0
+  version: 0.48.0
 platform: ruby
 authors:
 - Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-05 00:00:00.000000000 Z
+date: 2023-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -179,7 +179,6 @@ files:
 - 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
 - lib/haml_lint/severity.rb
@@ -221,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: HAML lint tool

data/lib/haml_lint/ruby_extractor.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-module HamlLint
-  # Utility class for extracting Ruby script from a HAML file that can then be
-  # linted with a Ruby linter (i.e. is "legal" Ruby). The goal is to turn this:
-  #
-  #     - if signed_in?(viewer)
-  #       %span Stuff
-  #       = link_to 'Sign Out', sign_out_path
-  #     - else
-  #       .some-class{ class: my_method }= my_method
-  #       = link_to 'Sign In', sign_in_path
-  #
-  # into this:
-  #
-  #     if signed_in?(viewer)
-  #       link_to 'Sign Out', sign_out_path
-  #     else
-  #       { class: my_method }
-  #       my_method
-  #       link_to 'Sign In', sign_in_path
-  #     end
-  #
-  # The translation won't be perfect, and won't make any real sense, but the
-  # relationship between variable declarations/uses and the flow control graph
-  # will remain intact.
-  class RubyExtractor
-    include HamlVisitor
-
-    # Stores the extracted source and a map of lines of generated source to the
-    # original source that created them.
-    #
-    # @attr_reader source [String] generated source code
-    # @attr_reader source_map [Hash] map of line numbers from generated source
-    #   to original source line number
-    RubySource = Struct.new(:source, :source_map)
-
-    # Extracts Ruby code from Sexp representing a Slim document.
-    #
-    # @param document [HamlLint::Document]
-    # @return [HamlLint::RubyExtractor::RubySource]
-    def extract(document)
-      visit(document.tree)
-      RubySource.new(@source_lines.join("\n"), @source_map)
-    end
-
-    def visit_root(_node)
-      @source_lines = []
-      @source_map = {}
-      @line_count = 0
-      @indent_level = 0
-      @output_count = 0
-
-      yield # Collect lines of code from children
-    end
-
-    def visit_plain(node)
-      # Don't output the text, as we don't want to have to deal with any RuboCop
-      # cops regarding StringQuotes or AsciiComments, and it's not important to
-      # overall document anyway.
-      add_dummy_puts(node)
-    end
-
-    def visit_tag(node)
-      additional_attributes = node.dynamic_attributes_sources
-
-      # Include dummy references to code executed in attributes list
-      # (this forces a "use" of a variable to prevent "assigned but unused
-      # variable" lints)
-      additional_attributes.each do |attributes_code|
-        # Normalize by removing excess whitespace to avoid format lints
-        attributes_code = attributes_code.gsub(/\s*\n\s*/, "\n").strip
-
-        # Attributes can either be a method call or a literal hash, so wrap it
-        # in a method call itself in order to avoid having to differentiate the
-        # two. Use the tag name for the method to differentiate different tag types
-        # for RuboCop and prevent erroneous warnings.
-        add_line("#{node.tag_name}(#{attributes_code})", node)
-      end
-
-      check_tag_static_hash_source(node)
-
-      # We add a dummy puts statement to represent the tag name being output.
-      # This prevents some erroneous RuboCop warnings.
-      add_dummy_puts(node, node.tag_name)
-
-      code = node.script.strip
-      add_line(code, node) unless code.empty?
-    end
-
-    def after_visit_tag(node)
-      # We add a dummy puts statement for closing tag.
-      add_dummy_puts(node, "#{node.tag_name}/")
-    end
-
-    def visit_script(node)
-      code = node.text
-
-      add_line(code.strip, node)
-
-      start_block = anonymous_block?(code) || start_block_keyword?(code)
-
-      if start_block
-        @indent_level += 1
-      end
-
-      yield # Continue extracting code from children
-
-      if start_block
-        @indent_level -= 1
-        add_line('end', node)
-      end
-    end
-
-    def visit_haml_comment(node)
-      # We want to preseve leading whitespace if it exists, but include leading
-      # whitespace if it doesn't exist so that RuboCop's LeadingCommentSpace
-      # doesn't complain
-      comment = node.text
-                    .gsub(/\n(\S)/, "\n# \\1")
-                    .gsub(/\n(\s)/, "\n#\\1")
-      add_line("##{comment}", node)
-    end
-
-    def visit_silent_script(node, &block)
-      visit_script(node, &block)
-    end
-
-    def visit_filter(node)
-      if node.filter_type == 'ruby'
-        node.text.split("\n").each_with_index do |line, index|
-          add_line(line, node.line + index + 1, discard_blanks: false)
-        end
-      else
-        add_dummy_puts(node, ":#{node.filter_type}")
-        HamlLint::Utils.extract_interpolated_values(node.text) do |interpolated_code, line|
-          add_line(interpolated_code, node.line + line)
-        end
-      end
-    end
-
-    private
-
-    def check_tag_static_hash_source(node)
-      # Haml::Parser converts hashrocket-style hash attributes of strings and symbols
-      # to static attributes, and excludes them from the dynamic attribute sources:
-      # https://github.com/haml/haml/blob/08f97ec4dc8f59fe3d7f6ab8f8807f86f2a15b68/lib/haml/parser.rb#L400-L404
-      # https://github.com/haml/haml/blob/08f97ec4dc8f59fe3d7f6ab8f8807f86f2a15b68/lib/haml/parser.rb#L540-L554
-      # Here, we add the hash source back in so it can be inspected by rubocop.
-      if node.hash_attributes? && node.dynamic_attributes_sources.empty?
-        normalized_attr_source = node.dynamic_attributes_source[:hash].gsub(/\s*\n\s*/, ' ')
-
-        add_line(normalized_attr_source, node)
-      end
-    end
-
-    # Adds a dummy method call with a unique name so we don't get
-    # Style/IdenticalConditionalBranches RuboCop warnings
-    def add_dummy_puts(node, annotation = nil)
-      annotation = " # #{annotation}" if annotation
-      add_line("_haml_lint_puts_#{@output_count}#{annotation}", node)
-      @output_count += 1
-    end
-
-    def add_line(code, node_or_line, discard_blanks: true)
-      return if code.empty? && discard_blanks
-
-      indent_level = @indent_level
-
-      if node_or_line.respond_to?(:line) && mid_block_keyword?(code)
-        # Since mid-block keywords are children of the corresponding start block
-        # keyword, we need to reduce their indentation level by 1. However, we
-        # don't do this unless this is an actual tag node (a raw line number
-        # means this came from a `:ruby` filter).
-        indent_level -= 1
-      end
-
-      indent = (' ' * 2 * indent_level)
-
-      @source_lines << indent_code(code, indent)
-
-      original_line =
-        node_or_line.respond_to?(:line) ? node_or_line.line : node_or_line
-
-      # For interpolated code in filters that spans multiple lines, the
-      # resulting code will span multiple lines, so we need to create a
-      # mapping for each line.
-      (code.count("\n") + 1).times do
-        @line_count += 1
-        @source_map[@line_count] = original_line
-      end
-    end
-
-    def indent_code(code, indent)
-      codes = code.split("\n")
-      codes.map { |c| indent + c }.join("\n")
-    end
-
-    def anonymous_block?(text)
-      text =~ /\bdo\s*(\|\s*[^|]*\s*\|)?(\s*#.*)?\z/
-    end
-
-    START_BLOCK_KEYWORDS = %w[if unless case begin for until while].freeze
-    def start_block_keyword?(text)
-      START_BLOCK_KEYWORDS.include?(block_keyword(text))
-    end
-
-    MID_BLOCK_KEYWORDS = %w[else elsif when rescue ensure].freeze
-    def mid_block_keyword?(text)
-      MID_BLOCK_KEYWORDS.include?(block_keyword(text))
-    end
-
-    LOOP_KEYWORDS = %w[for until while].freeze
-    def block_keyword(text)
-      # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
-      if (keyword = text[/\A\s*([^\s]+)\s+/, 1]) && LOOP_KEYWORDS.include?(keyword)
-        return keyword
-      end
-
-      return unless keyword = text.scan(Haml::Parser::BLOCK_KEYWORD_REGEX)[0]
-      keyword[0] || keyword[1]
-    end
-  end
-end