[close #32] Improve trailing end results

When the last keyword in a given logical "block" is missing the `end` then it's unclear if the missing end came from the surrounding block, or from the last keyword. Example:

```ruby
class Dog
  def bark
    puts "woof"
end
```

Before this patch the output of this code will be:

```
    ❯ 1  class Dog
``

With this patch the output of this code will be:

```
    ❯ 1  class Dog
    ❯ 2    def bark
    ❯ 4  end
```

There's some key realizations to get to this point. First, while the output of the "before" case only looks like it's one line, it's actually a much larger block that holds down to line 4 but everything else is hidden. Second: We can detect for this scenario using lexing but starting at the last end of the problem block and working backwards to find a mismatched keyword.

Author: schneems

CHANGELOG.md

@@ -1,6 +1,7 @@
 ## HEAD (unreleased)
 
 - Fix bug where empty lines were interpreted to have a zero indentation (https://github.com/zombocom/dead_end/pull/39)
+- Better results when missing "end" comes at the end of a capturing block (such as a class or module definition) (https://github.com/zombocom/dead_end/issues/32)
 
 ## 1.0.1
 

lib/dead_end/capture_code_context.rb

@@ -35,20 +35,9 @@ def initialize(blocks: , code_lines:)
 
     def call
       @blocks.each do |block|
-        around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
-          .start_at_next_line
-          .capture_neighbor_context
-
-        around_lines -= block.lines
-
-        @lines_to_output.concat(around_lines)
-
-        AroundBlockScan.new(
-          block: block,
-          code_lines: @code_lines,
-        ).on_falling_indent do |line|
-          @lines_to_output << line
-        end
+        capture_last_end_same_indent(block)
+        capture_before_after_kws(block)
+        capture_falling_indent(block)
       end
 
       @lines_to_output.select!(&:not_empty?)
@@ -58,5 +47,70 @@ def call
 
       return @lines_to_output
     end
+
+    def capture_falling_indent(block)
+      AroundBlockScan.new(
+        block: block,
+        code_lines: @code_lines,
+      ).on_falling_indent do |line|
+        @lines_to_output << line
+      end
+    end
+
+    def capture_before_after_kws(block)
+      around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
+        .start_at_next_line
+        .capture_neighbor_context
+
+      around_lines -= block.lines
+
+      @lines_to_output.concat(around_lines)
+    end
+
+    # Problems heredocs are back in play
+    def capture_last_end_same_indent(block)
+      start_index = block.visible_lines.first.index
+      lines = @code_lines[start_index..block.lines.last.index]
+      kw_end_lines = lines.select {|line| line.indent == block.current_indent && (line.is_end? || line.is_kw?) }
+
+
+      # TODO handle case of heredocs showing up here
+      #
+      # Due to https://github.com/zombocom/dead_end/issues/32
+      # There's a special case where a keyword right before the last
+      # end of a valid block accidentally ends up identifying that the problem
+      # was with the block instead of before it. To handle that
+      # special case, we can re-parse back through the internals of blocks
+      # and if they have mis-matched keywords and ends show the last one
+      end_lines = kw_end_lines.select(&:is_end?)
+      end_lines.each_with_index  do |end_line, i|
+        start_index = i.zero? ? 0 : end_lines[i-1].index
+        end_index = end_line.index - 1
+        lines = @code_lines[start_index..end_index]
+
+        stop_next = false
+        kw_count = 0
+        end_count = 0
+        lines = lines.reverse.take_while do |line|
+          next false if stop_next
+
+          end_count += 1 if line.is_end?
+          kw_count += 1 if line.is_kw?
+
+          stop_next = true if !kw_count.zero? && kw_count >= end_count
+          true
+        end.reverse
+
+        next unless kw_count > end_count
+
+        lines = lines.select {|line| line.is_kw? || line.is_end? }
+
+        next if lines.empty?
+
+        @lines_to_output << end_line
+        @lines_to_output << lines.first
+        @lines_to_output << lines.last
+      end
+    end
   end
 end

spec/unit/capture_code_context_spec.rb

@@ -4,6 +4,58 @@
 
 module DeadEnd
   RSpec.describe CaptureCodeContext do
+    it "shows ends of captured block" do
+      lines = fixtures_dir.join("rexe.rb.txt").read.lines
+      lines.delete_at(148 - 1)
+      source = lines.join
+
+      search = CodeSearch.new(source)
+      search.call
+
+      # expect(search.invalid_blocks.join.strip).to eq('class Dog')
+      display = CaptureCodeContext.new(
+        blocks: search.invalid_blocks,
+        code_lines: search.code_lines
+      )
+      lines = display.call
+
+      lines = lines.sort.map(&:original)
+      expect(lines.join).to eq(<<~EOM)
+        class Rexe
+          VERSION = '1.5.1'
+          PROJECT_URL = 'https://github.com/keithrbennett/rexe'
+          class Lookups
+            def format_requires
+          end
+          class CommandLineParser
+          end
+        end
+      EOM
+    end
+
+    it "shows ends of captured block" do
+      source = <<~'EOM'
+        class Dog
+          def bark
+            puts "woof"
+        end
+      EOM
+      search = CodeSearch.new(source)
+      search.call
+
+      expect(search.invalid_blocks.join.strip).to eq('class Dog')
+      display = CaptureCodeContext.new(
+        blocks: search.invalid_blocks,
+        code_lines: search.code_lines
+      )
+      lines = display.call.sort.map(&:original)
+      expect(lines.join).to eq(<<~EOM)
+        class Dog
+          def bark
+        end
+      EOM
+    end
+
     it "captures surrounding context on falling indent" do
       syntax_string = <<~EOM
         class Blerg
@@ -29,7 +81,7 @@ class Zerg
         blocks: search.invalid_blocks,
         code_lines: search.code_lines
       )
-      lines = display.call.sort
+      lines = display.call.sort.map(&:original)
       expect(lines.join).to eq(<<~EOM)
         class OH
           def hello