dead_end 3.1.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64abeaee0636d3ded8df0f0dc124674a70f954287b37302dff7151f04b746557
-  data.tar.gz: 02e6eea73a9e9e832b898f9294c1ce3f7f38f9b8996554a8f6527abf7027d115
+  metadata.gz: 655326e21a4ad4ae77a34020b69ce404f2405b2695b2e2e977c685352fcc0e79
+  data.tar.gz: 4a85b498c7d039a1ab016dae09775cb7a0a456c02a234ce83c5ac5776af97f0f
 SHA512:
-  metadata.gz: e7381458f44ef92f5053ac3171ac8bc59e89a805d793dde1c48ce1eda855dcea624ef6dc7a1faa3da9c20abc53983675fc66a7b08e3e02893801b4b4ff0edf65
-  data.tar.gz: 8b92dee56fac32777f31b76e25a0b778b2a4ffa1ff6914f24ef835bbf5ab79898f4a3a5607a9bebc641f86b05f2a88224504f0f8aaab83c3262b1d067ea32af0
+  metadata.gz: 409e22fe3a76ca5cc64a1886f58aaf8bcccc9b1f8564e580f8f1d70a63ba8a32216b6c2e9ac1e0c670b26e06a4a4b977d98562e4b9d2ea28a8bc30c3b096342f
+  data.tar.gz: 379bda579f643647303c39d409c4a675711e5c9679da123961b81b30b86d5b4133e8ea8636cf24eab757b4b262a2f8e93e977360b9a7ba68a5dfaa029e02fba2

data/.circleci/config.yml

@@ -47,12 +47,25 @@ jobs:
 
   "ruby-3-1":
     docker:
-      - image: 'cimg/base:stable'
+      - image: 'cimg/ruby:3.1'
     steps:
       - checkout
-      - ruby/install:
-          version: '3.1.0-preview1'
-      - run: ruby -v
+      - ruby/install-deps
+      - <<: *unit
+
+  "ruby-3-2":
+    docker:
+      - image: 'ruby:3.2.0-preview1'
+    steps:
+      - checkout
+      - ruby/install-deps
+      - <<: *unit
+  "ruby-3-2-yjit":
+    docker:
+      - image: 'ruby:3.2.0-preview1'
+    steps:
+      - run: echo "export RUBY_YJIT_ENABLE=1" >> $BASH_ENV
+      - checkout
       - ruby/install-deps
       - <<: *unit
 
@@ -73,4 +86,6 @@ workflows:
       - "ruby-2-7"
       - "ruby-3-0"
       - "ruby-3-1"
+      - "ruby-3-2"
+      - "ruby-3-2-yjit"
       - "lint"

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## HEAD (unreleased)
 
+## 4.0.0
+
+- Code that does not have an associated file (eval and streamed) no longer produce a warning saying that the file could not be found. To produce a warning with these code types run with DEBUG=1 environment variable. (https://github.com/zombocom/dead_end/pull/143)
+- [Breaking] Lazy load DeadEnd internals only if there is a Syntax error. Use `require "dead_end"; require "dead_end/api"` to load eagerly all internals. Otherwise `require "dead_end"` will set up an autoload for the first time the DeadEnd module is used in code. This should only happen on a syntax error. (https://github.com/zombocom/dead_end/pull/142)
+- Monkeypatch `SyntaxError#detailed_message` in Ruby 3.2+ instead of `require`, `load`, and `require_relative` (https://github.com/zombocom/dead_end/pull/139)
+
+## 3.1.2
+
+- Fixed internal class AroundBlockScan, minor changes in outputs (https://github.com/zombocom/dead_end/pull/131)
+
 ## 3.1.1
 
 - Fix case where Ripper lexing identified incorrect code as a keyword (https://github.com/zombocom/dead_end/pull/122)

data/Gemfile

@@ -10,3 +10,5 @@ gem "rspec", "~> 3.0"
 gem "stackprof"
 gem "standard"
 gem "ruby-prof"
+
+gem "benchmark-ips"

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    dead_end (3.1.1)
+    dead_end (4.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    benchmark-ips (2.9.2)
     diff-lcs (1.4.4)
     parallel (1.21.0)
     parser (3.0.2.0)
@@ -54,6 +55,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  benchmark-ips
   dead_end!
   rake (~> 12.0)
   rspec (~> 3.0)
@@ -62,4 +64,4 @@ DEPENDENCIES
   standard
 
 BUNDLED WITH
-   2.3.4
+   2.3.14

data/README.md

@@ -168,7 +168,7 @@ Here's an example:
 
 ## Use internals
 
-To use the `dead_end` gem without monkeypatching you can  `require 'dead_en/api'`. This will allow you to load `dead_end` and use its internals without mutating `require`.
+To use the `dead_end` gem without monkeypatching you can  `require 'dead_end/api'`. This will allow you to load `dead_end` and use its internals without mutating `require`.
 
 Stable internal interface(s):
 

data/dead_end.gemspec

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "lib/dead_end/version"
+begin
+  require_relative "lib/dead_end/version"
+rescue LoadError # Fallback to load version file in ruby core repository
+  require_relative "version"
+end
 
 Gem::Specification.new do |spec|
   spec.name = "dead_end"
-  spec.version = DeadEnd::VERSION
+  spec.version = UnloadedDeadEnd::VERSION
   spec.authors = ["schneems"]
   spec.email = ["richard.schneeman+foo@gmail.com"]
 

data/exe/dead_end

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require_relative "../lib/dead_end"
+require_relative "../lib/dead_end/api"
 
 DeadEnd::Cli.new(
   argv: ARGV

data/lib/dead_end/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "version"
 
 require "tmpdir"
@@ -7,6 +9,8 @@ require "ripper"
 require "timeout"
 
 module DeadEnd
+  VERSION = UnloadedDeadEnd::VERSION
+
   # Used to indicate a default value that cannot
   # be confused with another input.
   DEFAULT_VALUE = Object.new.freeze
@@ -16,7 +20,7 @@ module DeadEnd
 
   # DeadEnd.handle_error [Public]
   #
-  # Takes a `SyntaxError`` exception, uses the
+  # Takes a `SyntaxError` exception, uses the
   # error message to locate the file. Then the file
   # will be analyzed to find the location of the syntax
   # error and emit that location to stderr.
@@ -59,7 +63,7 @@ module DeadEnd
   # DeadEnd.call [Private]
   #
   # Main private interface
-  def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: nil, timeout: TIMEOUT_DEFAULT, io: $stderr)
+  def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)
     search = nil
     filename = nil if filename == DEFAULT_VALUE
     Timeout.timeout(timeout) do
@@ -189,8 +193,10 @@ require_relative "code_line"
 require_relative "code_block"
 require_relative "block_expand"
 require_relative "ripper_errors"
-require_relative "insertion_sort"
+require_relative "priority_queue"
+require_relative "unvisited_lines"
 require_relative "around_block_scan"
+require_relative "priority_engulf_queue"
 require_relative "pathname_from_message"
 require_relative "display_invalid_blocks"
 require_relative "parse_blocks_from_indent_line"

data/lib/dead_end/around_block_scan.rb

@@ -37,10 +37,20 @@ module DeadEnd
       @after_array = []
       @before_array = []
       @stop_after_kw = false
+
+      @skip_hidden = false
+      @skip_empty = false
     end
 
     def skip(name)
-      @skip_array << name
+      case name
+      when :hidden?
+        @skip_hidden = true
+      when :empty?
+        @skip_empty = true
+      else
+        raise "Unsupported skip #{name}"
+      end
       self
     end
 
@@ -49,14 +59,15 @@ module DeadEnd
       self
     end
 
-    def scan_while(&block)
+    def scan_while
       stop_next = false
 
       kw_count = 0
       end_count = 0
-      @before_index = before_lines.reverse_each.take_while do |line|
+      index = before_lines.reverse_each.take_while do |line|
         next false if stop_next
-        next true if @skip_array.detect { |meth| line.send(meth) }
+        next true if @skip_hidden && line.hidden?
+        next true if @skip_empty && line.empty?
 
         kw_count += 1 if line.is_kw?
         end_count += 1 if line.is_end?
@@ -64,15 +75,20 @@ module DeadEnd
           stop_next = true
         end
 
-        block.call(line)
+        yield line
       end.last&.index
 
+      if index && index < before_index
+        @before_index = index
+      end
+
       stop_next = false
       kw_count = 0
       end_count = 0
-      @after_index = after_lines.take_while do |line|
+      index = after_lines.take_while do |line|
         next false if stop_next
-        next true if @skip_array.detect { |meth| line.send(meth) }
+        next true if @skip_hidden && line.hidden?
+        next true if @skip_empty && line.empty?
 
         kw_count += 1 if line.is_kw?
         end_count += 1 if line.is_end?
@@ -80,8 +96,12 @@ module DeadEnd
           stop_next = true
         end
 
-        block.call(line)
+        yield line
       end.last&.index
+
+      if index && index > after_index
+        @after_index = index
+      end
       self
     end
 
@@ -178,7 +198,11 @@ module DeadEnd
     end
 
     def code_block
-      CodeBlock.new(lines: @code_lines[before_index..after_index])
+      CodeBlock.new(lines: lines)
+    end
+
+    def lines
+      @code_lines[before_index..after_index]
     end
 
     def before_index
@@ -190,7 +214,7 @@ module DeadEnd
     end
 
     private def before_lines
-      @code_lines[0...@orig_before_index] || []
+      @code_lines[0...before_index] || []
     end
 
     private def after_lines

data/lib/dead_end/block_expand.rb

@@ -36,7 +36,7 @@ module DeadEnd
     end
 
     def call(block)
-      if (next_block = expand_neighbors(block, grab_empty: true))
+      if (next_block = expand_neighbors(block))
         return next_block
       end
 
@@ -51,25 +51,24 @@ module DeadEnd
         .code_block
     end
 
-    def expand_neighbors(block, grab_empty: true)
-      scan = AroundBlockScan.new(code_lines: @code_lines, block: block)
+    def expand_neighbors(block)
+      expanded_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
         .skip(:hidden?)
         .stop_after_kw
         .scan_neighbors
+        .scan_while { |line| line.empty? } # Slurp up empties
+        .lines
 
-      # Slurp up empties
-      if grab_empty
-        scan = AroundBlockScan.new(code_lines: @code_lines, block: scan.code_block)
-          .scan_while { |line| line.empty? || line.hidden? }
-      end
-
-      new_block = scan.code_block
-
-      if block.lines == new_block.lines
+      if block.lines == expanded_lines
         nil
       else
-        new_block
+        CodeBlock.new(lines: expanded_lines)
       end
     end
+
+    # Managable rspec errors
+    def inspect
+      "#<DeadEnd::CodeBlock:0x0000123843lol >"
+    end
   end
 end

data/lib/dead_end/code_block.rb

@@ -18,11 +18,22 @@ module DeadEnd
   #
   class CodeBlock
     UNSET = Object.new.freeze
-    attr_reader :lines
+    attr_reader :lines, :starts_at, :ends_at
 
     def initialize(lines: [])
       @lines = Array(lines)
       @valid = UNSET
+      @deleted = false
+      @starts_at = @lines.first.number
+      @ends_at = @lines.last.number
+    end
+
+    def delete
+      @deleted = true
+    end
+
+    def deleted?
+      @deleted
     end
 
     def visible_lines
@@ -41,14 +52,6 @@ module DeadEnd
       @lines.all?(&:hidden?)
     end
 
-    def starts_at
-      @starts_at ||= @lines.first&.line_number
-    end
-
-    def ends_at
-      @ends_at ||= @lines.last&.line_number
-    end
-
     # This is used for frontier ordering, we are searching from
     # the largest indentation to the smallest. This allows us to
     # populate an array with multiple code blocks then call `sort!`

data/lib/dead_end/code_frontier.rb

@@ -50,18 +50,16 @@ module DeadEnd
   #   CodeFrontier#detect_invalid_blocks
   #
   class CodeFrontier
-    def initialize(code_lines:)
+    def initialize(code_lines:, unvisited: UnvisitedLines.new(code_lines: code_lines))
       @code_lines = code_lines
-      @frontier = InsertionSort.new
-      @unvisited_lines = @code_lines.sort_by(&:indent_index)
-      @visited_lines = {}
+      @unvisited = unvisited
+      @queue = PriorityEngulfQueue.new
 
-      @has_run = false
       @check_next = true
     end
 
     def count
-      @frontier.to_a.length
+      @queue.length
     end
 
     # Performance optimization
@@ -88,7 +86,7 @@ module DeadEnd
     # removed. By default it checks all blocks in present in
     # the frontier array, but can be used for arbitrary arrays
     # of codeblocks as well
-    def holds_all_syntax_errors?(block_array = @frontier, can_cache: true)
+    def holds_all_syntax_errors?(block_array = @queue, can_cache: true)
       return false if can_cache && can_skip_check?
 
       without_lines = block_array.to_a.flat_map do |block|
@@ -103,23 +101,23 @@ module DeadEnd
 
     # Returns a code block with the largest indentation possible
     def pop
-      @frontier.to_a.pop
+      @queue.pop
     end
 
     def next_indent_line
-      @unvisited_lines.last
+      @unvisited.peek
     end
 
     def expand?
-      return false if @frontier.to_a.empty?
-      return true if @unvisited_lines.to_a.empty?
+      return false if @queue.empty?
+      return true if @unvisited.empty?
 
-      frontier_indent = @frontier.to_a.last.current_indent
+      frontier_indent = @queue.peek.current_indent
       unvisited_indent = next_indent_line.indent
 
       if ENV["DEBUG"]
         puts "```"
-        puts @frontier.to_a.last.to_s
+        puts @queue.peek.to_s
         puts "```"
         puts "  @frontier indent:  #{frontier_indent}"
         puts "  @unvisited indent: #{unvisited_indent}"
@@ -129,33 +127,30 @@ module DeadEnd
       frontier_indent >= unvisited_indent
     end
 
+    # Keeps track of what lines have been added to blocks and which are not yet
+    # visited.
     def register_indent_block(block)
-      block.lines.each do |line|
-        next if @visited_lines[line]
-        @visited_lines[line] = true
-
-        index = @unvisited_lines.bsearch_index { |l| line.indent_index <=> l.indent_index }
-        @unvisited_lines.delete_at(index)
-      end
+      @unvisited.visit_block(block)
       self
     end
 
+    # When one element fully encapsulates another we remove the smaller
+    # block from the frontier. This prevents double expansions and all-around
+    # weird behavior. However this guarantee is quite expensive to maintain
+    def register_engulf_block(block)
+    end
+
     # Add a block to the frontier
     #
     # This method ensures the frontier always remains sorted (in indentation order)
     # and that each code block's lines are removed from the indentation hash so we
     # don't re-evaluate the same line multiple times.
     def <<(block)
-      register_indent_block(block)
+      @unvisited.visit_block(block)
 
-      # Make sure we don't double expand, if a code block fully engulfs another code block, keep the bigger one
-      @frontier.to_a.reject! { |b|
-        b.starts_at >= block.starts_at && b.ends_at <= block.ends_at
-      }
+      @queue.push(block)
 
       @check_next = true if block.invalid?
-      @frontier << block
-      # @frontier.sort!
 
       self
     end
@@ -175,7 +170,7 @@ module DeadEnd
     # Given that we know our syntax error exists somewhere in our frontier, we want to find
     # the smallest possible set of blocks that contain all the syntax errors
     def detect_invalid_blocks
-      self.class.combination(@frontier.to_a.select(&:invalid?)).detect do |block_array|
+      self.class.combination(@queue.to_a.select(&:invalid?)).detect do |block_array|
         holds_all_syntax_errors?(block_array, can_cache: false)
       end || []
     end

data/lib/dead_end/code_search.rb

@@ -41,7 +41,13 @@ module DeadEnd
 
     attr_reader :invalid_blocks, :record_dir, :code_lines
 
-    def initialize(source, record_dir: ENV["DEAD_END_RECORD_DIR"] || ENV["DEBUG"] ? "tmp" : nil)
+    def initialize(source, record_dir: DEFAULT_VALUE)
+      record_dir = if record_dir == DEFAULT_VALUE
+        ENV["DEAD_END_RECORD_DIR"] || ENV["DEBUG"] ? "tmp" : nil
+      else
+        record_dir
+      end
+
       if record_dir
         @record_dir = DeadEnd.record_dir(record_dir)
         @write_count = 0
@@ -63,7 +69,7 @@ module DeadEnd
     def record(block:, name: "record")
       return unless @record_dir
       @name_tick[name] += 1
-      filename = "#{@write_count += 1}-#{name}-#{@name_tick[name]}.txt"
+      filename = "#{@write_count += 1}-#{name}-#{@name_tick[name]}-(#{block.starts_at}__#{block.ends_at}).txt"
       if ENV["DEBUG"]
         puts "\n\n==== #{filename} ===="
         puts "\n```#{block.starts_at}..#{block.ends_at}"
@@ -78,7 +84,7 @@ module DeadEnd
           highlight_lines: block.lines
         ).call
 
-        f.write(document)
+        f.write("    Block lines: #{block.starts_at..block.ends_at} (#{name}) \n\n#{document}")
       end
     end
 
@@ -89,25 +95,13 @@ module DeadEnd
       frontier << block
     end
 
-    # Removes the block without putting it back in the frontier
-    def sweep(block:, name:)
-      record(block: block, name: name)
-
-      block.lines.each(&:mark_invisible)
-      frontier.register_indent_block(block)
-    end
-
     # Parses the most indented lines into blocks that are marked
     # and added to the frontier
-    def visit_new_blocks
+    def create_blocks_from_untracked_lines
       max_indent = frontier.next_indent_line&.indent
 
       while (line = frontier.next_indent_line) && (line.indent == max_indent)
-
         @parse_blocks_from_indent_line.each_neighbor_block(frontier.next_indent_line) do |block|
-          record(block: block, name: "add")
-
-          block.mark_invisible if block.valid?
           push(block, name: "add")
         end
       end
@@ -115,13 +109,12 @@ module DeadEnd
 
     # Given an already existing block in the frontier, expand it to see
     # if it contains our invalid syntax
-    def expand_invalid_block
+    def expand_existing
       block = frontier.pop
       return unless block
 
-      record(block: block, name: "pop")
+      record(block: block, name: "before-expand")
 
-      # block = block.expand_until_next_boundry
       block = @block_expand.call(block)
       push(block, name: "expand")
     end
@@ -132,9 +125,9 @@ module DeadEnd
         @tick += 1
 
         if frontier.expand?
-          expand_invalid_block
+          expand_existing
         else
-          visit_new_blocks
+          create_blocks_from_untracked_lines
         end
       end
 

data/lib/dead_end/core_ext.rb

@@ -1,35 +1,88 @@
 # frozen_string_literal: true
 
-# Monkey patch kernel to ensure that all `require` calls call the same
-# method
-module Kernel
-  module_function
-
-  alias_method :dead_end_original_require, :require
-  alias_method :dead_end_original_require_relative, :require_relative
-  alias_method :dead_end_original_load, :load
-
-  def load(file, wrap = false)
-    dead_end_original_load(file)
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
-  end
+# Allow lazy loading, only load code if/when there's a syntax error
+autoload :DeadEnd, "dead_end/api"
+
+# Ruby 3.2+ has a cleaner way to hook into Ruby that doesn't use `require`
+if SyntaxError.new.respond_to?(:detailed_message)
+  module DeadEndUnloaded
+    class MiniStringIO
+      def initialize(isatty: $stderr.isatty)
+        @string = +""
+        @isatty = isatty
+      end
 
-  def require(file)
-    dead_end_original_require(file)
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
+      attr_reader :isatty
+      def puts(value = $/, **)
+        @string << value
+      end
+
+      attr_reader :string
+    end
   end
 
-  def require_relative(file)
-    if Pathname.new(file).absolute?
-      dead_end_original_require file
-    else
-      relative_from = caller_locations(1..1).first
-      relative_from_path = relative_from.absolute_path || relative_from.path
-      dead_end_original_require File.expand_path("../#{file}", relative_from_path)
+  SyntaxError.prepend Module.new {
+    def detailed_message(highlight: nil, **)
+      message = super
+      file = DeadEnd::PathnameFromMessage.new(message).call.name
+      io = DeadEndUnloaded::MiniStringIO.new
+
+      if file
+        DeadEnd.call(
+          io: io,
+          source: file.read,
+          filename: file
+        )
+        annotation = io.string
+
+        annotation + message
+      else
+        message
+      end
+    rescue => e
+      if ENV["DEBUG"]
+        $stderr.warn(e.message)
+        $stderr.warn(e.backtrace)
+      end
+
+      # Ignore internal errors
+      message
+    end
+  }
+else
+  autoload :Pathname, "pathname"
+
+  # Monkey patch kernel to ensure that all `require` calls call the same
+  # method
+  module Kernel
+    module_function
+
+    alias_method :dead_end_original_require, :require
+    alias_method :dead_end_original_require_relative, :require_relative
+    alias_method :dead_end_original_load, :load
+
+    def load(file, wrap = false)
+      dead_end_original_load(file)
+    rescue SyntaxError => e
+      DeadEnd.handle_error(e)
+    end
+
+    def require(file)
+      dead_end_original_require(file)
+    rescue SyntaxError => e
+      DeadEnd.handle_error(e)
+    end
+
+    def require_relative(file)
+      if Pathname.new(file).absolute?
+        dead_end_original_require file
+      else
+        relative_from = caller_locations(1..1).first
+        relative_from_path = relative_from.absolute_path || relative_from.path
+        dead_end_original_require File.expand_path("../#{file}", relative_from_path)
+      end
+    rescue SyntaxError => e
+      DeadEnd.handle_error(e)
     end
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
   end
 end

data/lib/dead_end/parse_blocks_from_indent_line.rb

@@ -42,13 +42,18 @@ module DeadEnd
 
       neighbors = scan.code_block.lines
 
-      until neighbors.empty?
-        lines = [neighbors.pop]
-        while (block = CodeBlock.new(lines: lines)) && block.invalid? && neighbors.any?
-          lines.prepend neighbors.pop
-        end
+      block = CodeBlock.new(lines: neighbors)
+      if neighbors.length <= 2 || block.valid?
+        yield block
+      else
+        until neighbors.empty?
+          lines = [neighbors.pop]
+          while (block = CodeBlock.new(lines: lines)) && block.invalid? && neighbors.any?
+            lines.prepend neighbors.pop
+          end
 
-        yield block if block
+          yield block if block
+        end
       end
     end
   end

data/lib/dead_end/pathname_from_message.rb

@@ -13,6 +13,8 @@ module DeadEnd
   #    # => "/tmp/scratch.rb"
   #
   class PathnameFromMessage
+    EVAL_RE = /^\(eval\):\d+/
+    STREAMING_RE = /^-:\d+/
     attr_reader :name
 
     def initialize(message, io: $stderr)
@@ -24,14 +26,20 @@ module DeadEnd
     end
 
     def call
-      until stop?
-        @guess << @parts.shift
-        @name = Pathname(@guess.join(":"))
-      end
+      if skip_missing_file_name?
+        if ENV["DEBUG"]
+          @io.puts "DeadEnd: Could not find filename from #{@line.inspect}"
+        end
+      else
+        until stop?
+          @guess << @parts.shift
+          @name = Pathname(@guess.join(":"))
+        end
 
-      if @parts.empty?
-        @io.puts "DeadEnd: Could not find filename from #{@line.inspect}"
-        @name = nil
+        if @parts.empty?
+          @io.puts "DeadEnd: Could not find filename from #{@line.inspect}"
+          @name = nil
+        end
       end
 
       self
@@ -43,5 +51,9 @@ module DeadEnd
 
       @name&.exist?
     end
+
+    def skip_missing_file_name?
+      @line.match?(EVAL_RE) || @line.match?(STREAMING_RE)
+    end
   end
 end

data/lib/dead_end/priority_engulf_queue.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Keeps track of what elements are in the queue in
+  # priority and also ensures that when one element
+  # engulfs/covers/eats another that the larger element
+  # evicts the smaller element
+  class PriorityEngulfQueue
+    def initialize
+      @queue = PriorityQueue.new
+    end
+
+    def to_a
+      @queue.to_a
+    end
+
+    def empty?
+      @queue.empty?
+    end
+
+    def length
+      @queue.length
+    end
+
+    def peek
+      @queue.peek
+    end
+
+    def pop
+      @queue.pop
+    end
+
+    def push(block)
+      prune_engulf(block)
+      @queue << block
+      flush_deleted
+
+      self
+    end
+
+    private def flush_deleted
+      while @queue&.peek&.deleted?
+        @queue.pop
+      end
+    end
+
+    private def prune_engulf(block)
+      # If we're about to pop off the same block, we can skip deleting
+      # things from the frontier this iteration since we'll get it
+      # on the next iteration
+      return if @queue.peek && (block <=> @queue.peek) == 1
+
+      if block.starts_at != block.ends_at # A block of size 1 cannot engulf another
+        @queue.to_a.each { |b|
+          if b.starts_at >= block.starts_at && b.ends_at <= block.ends_at
+            b.delete
+            true
+          end
+        }
+      end
+    end
+  end
+end

data/lib/dead_end/priority_queue.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Holds elements in a priority heap on insert
+  #
+  # Instead of constantly calling `sort!`, put
+  # the element where it belongs the first time
+  # around
+  #
+  # Example:
+  #
+  #   queue = PriorityQueue.new
+  #   queue << 33
+  #   queue << 44
+  #   queue << 1
+  #
+  #   puts queue.peek # => 44
+  #
+  class PriorityQueue
+    attr_reader :elements
+
+    def initialize
+      @elements = []
+    end
+
+    def <<(element)
+      @elements << element
+      bubble_up(last_index, element)
+    end
+
+    def pop
+      exchange(0, last_index)
+      max = @elements.pop
+      bubble_down(0)
+      max
+    end
+
+    def length
+      @elements.length
+    end
+
+    def empty?
+      @elements.empty?
+    end
+
+    def peek
+      @elements.first
+    end
+
+    def to_a
+      @elements
+    end
+
+    # Used for testing, extremely not performant
+    def sorted
+      out = []
+      elements = @elements.dup
+      while (element = pop)
+        out << element
+      end
+      @elements = elements
+      out.reverse
+    end
+
+    private def last_index
+      @elements.size - 1
+    end
+
+    private def bubble_up(index, element)
+      return if index <= 0
+
+      parent_index = (index - 1) / 2
+      parent = @elements[parent_index]
+
+      return if (parent <=> element) >= 0
+
+      exchange(index, parent_index)
+      bubble_up(parent_index, element)
+    end
+
+    private def bubble_down(index)
+      child_index = (index * 2) + 1
+
+      return if child_index > last_index
+
+      not_the_last_element = child_index < last_index
+      left_element = @elements[child_index]
+      right_element = @elements[child_index + 1]
+
+      child_index += 1 if not_the_last_element && (right_element <=> left_element) == 1
+
+      return if (@elements[index] <=> @elements[child_index]) >= 0
+
+      exchange(index, child_index)
+      bubble_down(child_index)
+    end
+
+    def exchange(source, target)
+      a = @elements[source]
+      b = @elements[target]
+      @elements[source] = b
+      @elements[target] = a
+    end
+  end
+end

data/lib/dead_end/unvisited_lines.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Tracks which lines various code blocks have expanded to
+  # and which are still unexplored
+  class UnvisitedLines
+    def initialize(code_lines:)
+      @unvisited = code_lines.sort_by(&:indent_index)
+      @visited_lines = {}
+      @visited_lines.compare_by_identity
+    end
+
+    def empty?
+      @unvisited.empty?
+    end
+
+    def peek
+      @unvisited.last
+    end
+
+    def pop
+      @unvisited.pop
+    end
+
+    def visit_block(block)
+      block.lines.each do |line|
+        next if @visited_lines[line]
+        @visited_lines[line] = true
+      end
+
+      while @visited_lines[@unvisited.last]
+        @unvisited.pop
+      end
+    end
+  end
+end

data/lib/dead_end/version.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
-module DeadEnd
-  VERSION = "3.1.1"
+# Calling `DeadEnd::VERSION` forces an eager load due to
+# an `autoload` on the `DeadEnd` constant.
+#
+# This is used for gemspec access in tests
+module UnloadedDeadEnd
+  VERSION = "4.0.0"
 end

data/lib/dead_end.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-require_relative "dead_end/api"
 require_relative "dead_end/core_ext"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dead_end
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 4.0.0
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-04 00:00:00.000000000 Z
+date: 2022-06-02 00:00:00.000000000 Z
 dependencies: []
 description: When you get an "unexpected end" in your syntax this gem helps you find
   it
@@ -51,13 +51,15 @@ files:
 - lib/dead_end/display_code_with_line_numbers.rb
 - lib/dead_end/display_invalid_blocks.rb
 - lib/dead_end/explain_syntax.rb
-- lib/dead_end/insertion_sort.rb
 - lib/dead_end/left_right_lex_count.rb
 - lib/dead_end/lex_all.rb
 - lib/dead_end/lex_value.rb
 - lib/dead_end/parse_blocks_from_indent_line.rb
 - lib/dead_end/pathname_from_message.rb
+- lib/dead_end/priority_engulf_queue.rb
+- lib/dead_end/priority_queue.rb
 - lib/dead_end/ripper_errors.rb
+- lib/dead_end/unvisited_lines.rb
 - lib/dead_end/version.rb
 homepage: https://github.com/zombocom/dead_end.git
 licenses:
@@ -80,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Find syntax errors in your source in a snap

data/lib/dead_end/insertion_sort.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module DeadEnd
-  # Sort elements on insert
-  #
-  # Instead of constantly calling `sort!`, put
-  # the element where it belongs the first time
-  # around
-  #
-  # Example:
-  #
-  #   sorted = InsertionSort.new
-  #   sorted << 33
-  #   sorted << 44
-  #   sorted << 1
-  #   puts sorted.to_a
-  #   # => [1, 44, 33]
-  #
-  class InsertionSort
-    def initialize
-      @array = []
-    end
-
-    def <<(value)
-      insert_in = @array.length
-      @array.each.with_index do |existing, index|
-        case value <=> existing
-        when -1
-          insert_in = index
-          break
-        when 0
-          insert_in = index
-          break
-        when 1
-          # Keep going
-        end
-      end
-
-      @array.insert(insert_in, value)
-    end
-
-    def to_a
-      @array
-    end
-  end
-end