syntax_suggest 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a639824437777dc3bf6d77a9cf9eddd4621c6c2017531fd28d4cca6761c3a40e
-  data.tar.gz: 5631275dc4982eacbc44f994a46f9649d4fd848c0934c8a561f12facb5342c6c
+  metadata.gz: 0aa200b221c59254250acfa3343365ead0a7e8a0e699aec254e248a880bf4084
+  data.tar.gz: e343f13b8cfb3091b7e6f2ee97575fbe7e8e9b24d0f36168524a098e5d596098
 SHA512:
-  metadata.gz: 3f0a4fd6d41d847338f937e72d330665628d1b515a00f97c5492275e40b5c70d7381fdea0cd603341b15f1aea6d6a6d11a20bd8e4313ed2175876d59e2341c1d
-  data.tar.gz: d03f166ad6bac24822dfded00ed84a6bd96eaf4c059ed9abcacab065abd3edc28abfbbfaca9316ae0a84c3da13e155cac0c305f4bdd7070e0af0f958d4c4e781
+  metadata.gz: 5b5fe319b21f699251eb9d2a1580808fd8b454c8c5d04f1e0ac63619898c429726579596e2f182d98299f2850387ee34b245b6e4a9cfcfb17a1c76e160000a01
+  data.tar.gz: f1181078cb45c2c333fc96ff04efd0513b0da4088623ce9899eeda0ada7ba342d7a146bde872515678005cad6f200fe6116f4d33f600cd98f4aa520a13ccda21

data/.github/workflows/check_changelog.yml

@@ -13,7 +13,7 @@ jobs:
       !contains(github.event.pull_request.body, '[skip ci]') &&
       !contains(github.event.pull_request.labels.*.name, 'skip changelog')
     steps:
-      - uses: actions/checkout@v3.3.0
+      - uses: actions/checkout@v3.5.2
       - name: Check that CHANGELOG is touched
         run: |
           git fetch origin ${{ github.base_ref }} --depth 1 && \

data/.github/workflows/ci.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3.3.0
+        uses: actions/checkout@v3.5.2
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -33,7 +33,7 @@ jobs:
           - head
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3.3.0
+        uses: actions/checkout@v3.5.2
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## HEAD (unreleased)
 
+## 1.1.0
+
+- Handle if/else with comment or empty line in branch (https://github.com/ruby/syntax_suggest/pull/193)
+- Use `SYNTAX_SUGGEST_DEBUG` instead of `DEBUG` env var value in timeout warning message (https://github.com/ruby/syntax_suggest/pull/194)
+- Reduce line output for increased clarity (https://github.com/ruby/syntax_suggest/pull/190)
+
 ## 1.0.4
 
 - Fix rendering a file without a newline ending (https://github.com/ruby/syntax_suggest/pull/182)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_suggest (1.0.4)
+    syntax_suggest (1.1.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/syntax_suggest/api.rb

@@ -78,7 +78,7 @@ module SyntaxSuggest
       code_lines: search.code_lines
     ).call
   rescue Timeout::Error => e
-    io.puts "Search timed out SYNTAX_SUGGEST_TIMEOUT=#{timeout}, run with DEBUG=1 for more info"
+    io.puts "Search timed out SYNTAX_SUGGEST_TIMEOUT=#{timeout}, run with SYNTAX_SUGGEST_DEBUG=1 for more info"
     io.puts e.backtrace.first(3).join($/)
   end
 

data/lib/syntax_suggest/around_block_scan.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "scan_history"
+
 module SyntaxSuggest
   # This class is useful for exploring contents before and after
   # a block
@@ -24,22 +26,17 @@ module SyntaxSuggest
   #   puts scan.before_index # => 0
   #   puts scan.after_index  # => 3
   #
-  # Contents can also be filtered using AroundBlockScan#skip
-  #
-  # To grab the next surrounding indentation use AroundBlockScan#scan_adjacent_indent
   class AroundBlockScan
     def initialize(code_lines:, block:)
       @code_lines = code_lines
-      @orig_before_index = block.lines.first.index
-      @orig_after_index = block.lines.last.index
       @orig_indent = block.current_indent
-      @skip_array = []
-      @after_array = []
-      @before_array = []
-      @stop_after_kw = false
 
-      @force_add_hidden = false
+      @stop_after_kw = false
       @force_add_empty = false
+      @force_add_hidden = false
+      @target_indent = nil
+
+      @scanner = ScanHistory.new(code_lines: code_lines, block: block)
     end
 
     # When using this flag, `scan_while` will
@@ -89,150 +86,35 @@ module SyntaxSuggest
     # stopping if we've found a keyword/end mis-match in one direction
     # or the other.
     def scan_while
-      stop_next = false
-      kw_count = 0
-      end_count = 0
-      index = before_lines.reverse_each.take_while do |line|
-        next false if stop_next
-        next true if @force_add_hidden && line.hidden?
-        next true if @force_add_empty && line.empty?
-
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-        if @stop_after_kw && kw_count > end_count
-          stop_next = true
-        end
-
-        yield line
-      end.last&.index
-
-      if index && index < before_index
-        @before_index = index
-      end
-
-      stop_next = false
-      kw_count = 0
-      end_count = 0
-      index = after_lines.take_while do |line|
-        next false if stop_next
-        next true if @force_add_hidden && line.hidden?
-        next true if @force_add_empty && line.empty?
-
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-        if @stop_after_kw && end_count > kw_count
-          stop_next = true
-        end
-
-        yield line
-      end.last&.index
-
-      if index && index > after_index
-        @after_index = index
-      end
-      self
-    end
-
-    # Shows surrounding kw/end pairs
-    #
-    # The purpose of showing these extra pairs is due to cases
-    # of ambiguity when only one visible line is matched.
-    #
-    # For example:
-    #
-    #     1  class Dog
-    #     2    def bark
-    #     4    def eat
-    #     5    end
-    #     6  end
-    #
-    # In this case either line 2 could be missing an `end` or
-    # line 4 was an extra line added by mistake (it happens).
-    #
-    # When we detect the above problem it shows the issue
-    # as only being on line 2
-    #
-    #     2    def bark
-    #
-    # Showing "neighbor" keyword pairs gives extra context:
-    #
-    #     2    def bark
-    #     4    def eat
-    #     5    end
-    #
-    def capture_neighbor_context
-      lines = []
-      kw_count = 0
-      end_count = 0
-      before_lines.reverse_each do |line|
-        next if line.empty?
-        break if line.indent < @orig_indent
-        next if line.indent != @orig_indent
-
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-        if kw_count != 0 && kw_count == end_count
-          lines << line
-          break
-        end
-
-        lines << line
-      end
+      stop_next_up = false
+      stop_next_down = false
 
-      lines.reverse!
+      @scanner.scan(
+        up: ->(line, kw_count, end_count) {
+          next false if stop_next_up
+          next true if @force_add_hidden && line.hidden?
+          next true if @force_add_empty && line.empty?
 
-      kw_count = 0
-      end_count = 0
-      after_lines.each do |line|
-        next if line.empty?
-        break if line.indent < @orig_indent
-        next if line.indent != @orig_indent
+          if @stop_after_kw && kw_count > end_count
+            stop_next_up = true
+          end
 
-        kw_count += 1 if line.is_kw?
-        end_count += 1 if line.is_end?
-        if kw_count != 0 && kw_count == end_count
-          lines << line
-          break
-        end
-
-        lines << line
-      end
+          yield line
+        },
+        down: ->(line, kw_count, end_count) {
+          next false if stop_next_down
+          next true if @force_add_hidden && line.hidden?
+          next true if @force_add_empty && line.empty?
 
-      lines
-    end
+          if @stop_after_kw && end_count > kw_count
+            stop_next_down = true
+          end
 
-    # Shows the context around code provided by "falling" indentation
-    #
-    # Converts:
-    #
-    #       it "foo" do
-    #
-    # into:
-    #
-    #   class OH
-    #     def hello
-    #       it "foo" do
-    #     end
-    #   end
-    #
-    def on_falling_indent
-      last_indent = @orig_indent
-      before_lines.reverse_each do |line|
-        next if line.empty?
-        if line.indent < last_indent
           yield line
-          last_indent = line.indent
-        end
-      end
+        }
+      )
 
-      last_indent = @orig_indent
-      after_lines.each do |line|
-        next if line.empty?
-        if line.indent < last_indent
-          yield line
-          last_indent = line.indent
-        end
-      end
+      self
     end
 
     # Scanning is intentionally conservative because
@@ -266,39 +148,46 @@ module SyntaxSuggest
 
       return self if kw_count == end_count # nothing to balance
 
-      # More ends than keywords, check if we can balance expanding up
-      if (end_count - kw_count) == 1 && next_up
-        return self unless next_up.is_kw?
-        return self unless next_up.indent >= @orig_indent
-
-        @before_index = next_up.index
+      @scanner.commit_if_changed # Rollback point if we don't find anything to optimize
 
-      # More keywords than ends, check if we can balance by expanding down
-      elsif (kw_count - end_count) == 1 && next_down
-        return self unless next_down.is_end?
-        return self unless next_down.indent >= @orig_indent
+      # Try to eat up empty lines
+      @scanner.scan(
+        up: ->(line, _, _) { line.hidden? || line.empty? },
+        down: ->(line, _, _) { line.hidden? || line.empty? }
+      )
 
-        @after_index = next_down.index
+      # More ends than keywords, check if we can balance expanding up
+      next_up = @scanner.next_up
+      next_down = @scanner.next_down
+      case end_count - kw_count
+      when 1
+        if next_up&.is_kw? && next_up.indent >= @target_indent
+          @scanner.scan(
+            up: ->(line, _, _) { line == next_up },
+            down: ->(line, _, _) { false }
+          )
+          @scanner.commit_if_changed
+        end
+      when -1
+        if next_down&.is_end? && next_down.indent >= @target_indent
+          @scanner.scan(
+            up: ->(line, _, _) { false },
+            down: ->(line, _, _) { line == next_down }
+          )
+          @scanner.commit_if_changed
+        end
       end
+      # Rollback any uncommitted changes
+      @scanner.stash_changes
+
       self
     end
 
     # Finds code lines at the same or greater indentation and adds them
     # to the block
     def scan_neighbors_not_empty
-      scan_while { |line| line.not_empty? && line.indent >= @orig_indent }
-    end
-
-    # Returns the next line to be scanned above the current block.
-    # Returns `nil` if at the top of the document already
-    def next_up
-      @code_lines[before_index.pred]
-    end
-
-    # Returns the next line to be scanned below the current block.
-    # Returns `nil` if at the bottom of the document already
-    def next_down
-      @code_lines[after_index.next]
+      @target_indent = @orig_indent
+      scan_while { |line| line.not_empty? && line.indent >= @target_indent }
     end
 
     # Scan blocks based on indentation of next line above/below block
@@ -310,30 +199,13 @@ module SyntaxSuggest
     # the `def/end` lines surrounding a method.
     def scan_adjacent_indent
       before_after_indent = []
-      before_after_indent << (next_up&.indent || 0)
-      before_after_indent << (next_down&.indent || 0)
 
-      indent = before_after_indent.min
-      scan_while { |line| line.not_empty? && line.indent >= indent }
+      before_after_indent << (@scanner.next_up&.indent || 0)
+      before_after_indent << (@scanner.next_down&.indent || 0)
 
-      self
-    end
+      @target_indent = before_after_indent.min
+      scan_while { |line| line.not_empty? && line.indent >= @target_indent }
 
-    # TODO: Doc or delete
-    #
-    # I don't remember why this is needed, but it's called in code_context.
-    # It's related to the implementation of `capture_neighbor_context` somehow
-    # and that display improvement is only triggered when there's one visible line
-    #
-    # I think the primary purpose is to not include the current line in the
-    # logic evaluation of `capture_neighbor_context`. If that's true, then
-    # we should fix that method to handle this logic instead of only using
-    # it in one place and together.
-    def start_at_next_line
-      before_index
-      after_index
-      @before_index -= 1
-      @after_index += 1
       self
     end
 
@@ -349,29 +221,12 @@ module SyntaxSuggest
     # Returns the lines matched by the current scan as an
     # array of CodeLines
     def lines
-      @code_lines[before_index..after_index]
-    end
-
-    # Gives the index of the first line currently scanned
-    def before_index
-      @before_index ||= @orig_before_index
-    end
-
-    # Gives the index of the last line currently scanned
-    def after_index
-      @after_index ||= @orig_after_index
-    end
-
-    # Returns an array of all the CodeLines that exist before
-    # the currently scanned block
-    private def before_lines
-      @code_lines[0...before_index] || []
+      @scanner.lines
     end
 
-    # Returns an array of all the CodeLines that exist after
-    # the currently scanned block
-    private def after_lines
-      @code_lines[after_index.next..-1] || []
+    # Managable rspec errors
+    def inspect
+      "#<#{self.class}:0x0000123843lol >"
     end
   end
 end

data/lib/syntax_suggest/block_expand.rb

@@ -61,11 +61,14 @@ module SyntaxSuggest
     # they can expand to capture more code up and down). It does this conservatively
     # as there's no undo (currently).
     def expand_indent(block)
-      AroundBlockScan.new(code_lines: @code_lines, block: block)
+      now = AroundBlockScan.new(code_lines: @code_lines, block: block)
         .force_add_hidden
         .stop_after_kw
         .scan_adjacent_indent
-        .code_block
+
+      now.lookahead_balance_one_line
+
+      now.code_block
     end
 
     # A neighbor is code that is at or above the current indent line.
@@ -125,17 +128,20 @@ module SyntaxSuggest
     #
     # We try to resolve this edge case with `lookahead_balance_one_line` below.
     def expand_neighbors(block)
-      neighbors = AroundBlockScan.new(code_lines: @code_lines, block: block)
+      now = AroundBlockScan.new(code_lines: @code_lines, block: block)
+
+      # Initial scan
+      now
         .force_add_hidden
         .stop_after_kw
         .scan_neighbors_not_empty
 
       # Slurp up empties
-      with_empties = neighbors
+      now
         .scan_while { |line| line.empty? }
 
       # If next line is kw and it will balance us, take it
-      expanded_lines = with_empties
+      expanded_lines = now
         .lookahead_balance_one_line
         .lines
 

data/lib/syntax_suggest/capture/before_after_keyword_ends.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SyntaxSuggest
+  module Capture
+    # Shows surrounding kw/end pairs
+    #
+    # The purpose of showing these extra pairs is due to cases
+    # of ambiguity when only one visible line is matched.
+    #
+    # For example:
+    #
+    #     1  class Dog
+    #     2    def bark
+    #     4    def eat
+    #     5    end
+    #     6  end
+    #
+    # In this case either line 2 could be missing an `end` or
+    # line 4 was an extra line added by mistake (it happens).
+    #
+    # When we detect the above problem it shows the issue
+    # as only being on line 2
+    #
+    #     2    def bark
+    #
+    # Showing "neighbor" keyword pairs gives extra context:
+    #
+    #     2    def bark
+    #     4    def eat
+    #     5    end
+    #
+    #
+    # Example:
+    #
+    #   lines = BeforeAfterKeywordEnds.new(
+    #     block: block,
+    #     code_lines: code_lines
+    #   ).call()
+    #
+    class BeforeAfterKeywordEnds
+      def initialize(code_lines:, block:)
+        @scanner = ScanHistory.new(code_lines: code_lines, block: block)
+        @original_indent = block.current_indent
+      end
+
+      def call
+        lines = []
+
+        @scanner.scan(
+          up: ->(line, kw_count, end_count) {
+            next true if line.empty?
+            break if line.indent < @original_indent
+            next true if line.indent != @original_indent
+
+            # If we're going up and have one complete kw/end pair, stop
+            if kw_count != 0 && kw_count == end_count
+              lines << line
+              break
+            end
+
+            lines << line if line.is_kw? || line.is_end?
+            true
+          },
+          down: ->(line, kw_count, end_count) {
+            next true if line.empty?
+            break if line.indent < @original_indent
+            next true if line.indent != @original_indent
+
+            # if we're going down and have one complete kw/end pair,stop
+            if kw_count != 0 && kw_count == end_count
+              lines << line
+              break
+            end
+
+            lines << line if line.is_kw? || line.is_end?
+            true
+          }
+        )
+        @scanner.stash_changes
+
+        lines
+      end
+    end
+  end
+end

data/lib/syntax_suggest/capture/falling_indent_lines.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SyntaxSuggest
+  module Capture
+    # Shows the context around code provided by "falling" indentation
+    #
+    # If this is the original code lines:
+    #
+    #   class OH
+    #     def hello
+    #       it "foo" do
+    #     end
+    #   end
+    #
+    # And this is the line that is captured
+    #
+    #       it "foo" do
+    #
+    # It will yield its surrounding context:
+    #
+    #   class OH
+    #     def hello
+    #     end
+    #   end
+    #
+    # Example:
+    #
+    #   FallingIndentLines.new(
+    #       block: block,
+    #       code_lines: @code_lines
+    #   ).call do |line|
+    #     @lines_to_output << line
+    #   end
+    #
+    class FallingIndentLines
+      def initialize(code_lines:, block:)
+        @lines = nil
+        @scanner = ScanHistory.new(code_lines: code_lines, block: block)
+        @original_indent = block.current_indent
+      end
+
+      def call(&yieldable)
+        last_indent_up = @original_indent
+        last_indent_down = @original_indent
+
+        @scanner.commit_if_changed
+        @scanner.scan(
+          up: ->(line, _, _) {
+            next true if line.empty?
+
+            if line.indent < last_indent_up
+              yieldable.call(line)
+              last_indent_up = line.indent
+            end
+            true
+          },
+          down: ->(line, _, _) {
+            next true if line.empty?
+
+            if line.indent < last_indent_down
+              yieldable.call(line)
+              last_indent_down = line.indent
+            end
+            true
+          }
+        )
+        @scanner.stash_changes
+      end
+    end
+  end
+end

data/lib/syntax_suggest/capture_code_context.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+module SyntaxSuggest
+  module Capture
+  end
+end
+
+require_relative "capture/falling_indent_lines"
+require_relative "capture/before_after_keyword_ends"
+
 module SyntaxSuggest
   # Turns a "invalid block(s)" into useful context
   #
@@ -55,6 +63,10 @@ module SyntaxSuggest
         capture_falling_indent(block)
       end
 
+      sorted_lines
+    end
+
+    def sorted_lines
       @lines_to_output.select!(&:not_empty?)
       @lines_to_output.uniq!
       @lines_to_output.sort!
@@ -77,10 +89,10 @@ module SyntaxSuggest
     #   end
     #
     def capture_falling_indent(block)
-      AroundBlockScan.new(
+      Capture::FallingIndentLines.new(
         block: block,
         code_lines: @code_lines
-      ).on_falling_indent do |line|
+      ).call do |line|
         @lines_to_output << line
       end
     end
@@ -115,9 +127,10 @@ module SyntaxSuggest
     def capture_before_after_kws(block)
       return unless block.visible_lines.count == 1
 
-      around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
-        .start_at_next_line
-        .capture_neighbor_context
+      around_lines = Capture::BeforeAfterKeywordEnds.new(
+        code_lines: @code_lines,
+        block: block
+      ).call
 
       around_lines -= block.lines
 

data/lib/syntax_suggest/scan_history.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module SyntaxSuggest
+  # Scans up/down from the given block
+  #
+  # You can try out a change, stash it, or commit it to save for later
+  #
+  # Example:
+  #
+  #   scanner = ScanHistory.new(code_lines: code_lines, block: block)
+  #   scanner.scan(
+  #     up: ->(_, _, _) { true },
+  #     down: ->(_, _, _) { true }
+  #   )
+  #   scanner.changed? # => true
+  #   expect(scanner.lines).to eq(code_lines)
+  #
+  #   scanner.stash_changes
+  #
+  #   expect(scanner.lines).to_not eq(code_lines)
+  class ScanHistory
+    attr_reader :before_index, :after_index
+
+    def initialize(code_lines:, block:)
+      @code_lines = code_lines
+      @history = [block]
+      refresh_index
+    end
+
+    def commit_if_changed
+      if changed?
+        @history << CodeBlock.new(lines: @code_lines[before_index..after_index])
+      end
+
+      self
+    end
+
+    # Discards any changes that have not been committed
+    def stash_changes
+      refresh_index
+      self
+    end
+
+    # Discard changes that have not been committed and revert the last commit
+    #
+    # Cannot revert the first commit
+    def revert_last_commit
+      if @history.length > 1
+        @history.pop
+        refresh_index
+      end
+
+      self
+    end
+
+    def changed?
+      @before_index != current.lines.first.index ||
+        @after_index != current.lines.last.index
+    end
+
+    # Iterates up and down
+    #
+    # Returns line, kw_count, end_count for each iteration
+    def scan(up:, down:)
+      kw_count = 0
+      end_count = 0
+
+      up_index = before_lines.reverse_each.take_while do |line|
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+        up.call(line, kw_count, end_count)
+      end.last&.index
+
+      kw_count = 0
+      end_count = 0
+
+      down_index = after_lines.each.take_while do |line|
+        kw_count += 1 if line.is_kw?
+        end_count += 1 if line.is_end?
+        down.call(line, kw_count, end_count)
+      end.last&.index
+
+      @before_index = if up_index && up_index < @before_index
+        up_index
+      else
+        @before_index
+      end
+
+      @after_index = if down_index && down_index > @after_index
+        down_index
+      else
+        @after_index
+      end
+
+      self
+    end
+
+    def next_up
+      return nil if @before_index <= 0
+
+      @code_lines[@before_index - 1]
+    end
+
+    def next_down
+      return nil if @after_index >= @code_lines.length
+
+      @code_lines[@after_index + 1]
+    end
+
+    def lines
+      @code_lines[@before_index..@after_index]
+    end
+
+    private def before_lines
+      @code_lines[0...@before_index] || []
+    end
+
+    # Returns an array of all the CodeLines that exist after
+    # the currently scanned block
+    private def after_lines
+      @code_lines[@after_index.next..-1] || []
+    end
+
+    private def current
+      @history.last
+    end
+
+    private def refresh_index
+      @before_index = current.lines.first.index
+      @after_index = current.lines.last.index
+      self
+    end
+  end
+end

data/lib/syntax_suggest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxSuggest
-  VERSION = "1.0.4"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_suggest
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-17 00:00:00.000000000 Z
+date: 2023-05-08 00:00:00.000000000 Z
 dependencies: []
 description: When you get an "unexpected end" in your syntax this gem helps you find
   it
@@ -42,6 +42,8 @@ files:
 - lib/syntax_suggest/api.rb
 - lib/syntax_suggest/around_block_scan.rb
 - lib/syntax_suggest/block_expand.rb
+- lib/syntax_suggest/capture/before_after_keyword_ends.rb
+- lib/syntax_suggest/capture/falling_indent_lines.rb
 - lib/syntax_suggest/capture_code_context.rb
 - lib/syntax_suggest/clean_document.rb
 - lib/syntax_suggest/cli.rb
@@ -61,6 +63,7 @@ files:
 - lib/syntax_suggest/priority_engulf_queue.rb
 - lib/syntax_suggest/priority_queue.rb
 - lib/syntax_suggest/ripper_errors.rb
+- lib/syntax_suggest/scan_history.rb
 - lib/syntax_suggest/unvisited_lines.rb
 - lib/syntax_suggest/version.rb
 - syntax_suggest.gemspec
@@ -85,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Find syntax errors in your source in a snap