dead_end 3.0.3 → 3.1.2

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

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

data/lib/dead_end/lex_all.rb

@@ -25,7 +25,10 @@ module DeadEnd
         lineno = @lex.last.pos.first + 1
       end
 
-      @lex.map! { |elem| LexValue.new(elem.pos.first, elem.event, elem.tok, elem.state) }
+      last_lex = nil
+      @lex.map! { |elem|
+        last_lex = LexValue.new(elem.pos.first, elem.event, elem.tok, elem.state, last_lex)
+      }
     end
 
     def to_a

data/lib/dead_end/lex_value.rb

@@ -15,19 +15,21 @@ module DeadEnd
   class LexValue
     attr_reader :line, :type, :token, :state
 
-    def initialize(line, type, token, state)
+    def initialize(line, type, token, state, last_lex = nil)
       @line = line
       @type = type
       @token = token
       @state = state
 
-      set_kw_end
+      set_kw_end(last_lex)
     end
 
-    private def set_kw_end
+    private def set_kw_end(last_lex)
       @is_end = false
       @is_kw = false
       return if type != :on_kw
+      #
+      return if last_lex && last_lex.fname? # https://github.com/ruby/ruby/commit/776759e300e4659bb7468e2b97c8c2d4359a2953
 
       case token
       when "if", "unless", "while", "until"
@@ -41,6 +43,10 @@ module DeadEnd
       end
     end
 
+    def fname?
+      state.allbits?(Ripper::EXPR_FNAME)
+    end
+
     def ignore_newline?
       type == :on_ignored_nl
     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

@@ -30,7 +30,7 @@ module DeadEnd
       end
 
       if @parts.empty?
-        @io.puts "DeadEnd: could not find filename from #{@line.inspect}"
+        @io.puts "DeadEnd: Could not find filename from #{@line.inspect}"
         @name = nil
       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,5 @@
 # frozen_string_literal: true
 
 module DeadEnd
-  VERSION = "3.0.3"
+  VERSION = "3.1.2"
 end

data/lib/dead_end.rb

@@ -1,164 +1,4 @@
 # frozen_string_literal: true
 
-require_relative "dead_end/version"
-
-require "tmpdir"
-require "stringio"
-require "pathname"
-require "ripper"
-require "timeout"
-
-module DeadEnd
-  # Used to indicate a default value that cannot
-  # be confused with another input
-  DEFAULT_VALUE = Object.new.freeze
-
-  class Error < StandardError; end
-  TIMEOUT_DEFAULT = ENV.fetch("DEAD_END_TIMEOUT", 1).to_i
-
-  def self.handle_error(e)
-    file = PathnameFromMessage.new(e.message).call.name
-    raise e unless file
-
-    $stderr.sync = true
-
-    call(
-      source: file.read,
-      filename: file
-    )
-
-    raise e
-  end
-
-  def self.record_dir(dir)
-    time = Time.now.strftime("%Y-%m-%d-%H-%M-%s-%N")
-    dir = Pathname(dir)
-    symlink = dir.join("last").tap { |path| path.delete if path.exist? }
-    dir.join(time).tap { |path|
-      path.mkpath
-      FileUtils.symlink(path.basename, symlink)
-    }
-  end
-
-  def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: nil, timeout: TIMEOUT_DEFAULT, io: $stderr)
-    search = nil
-    filename = nil if filename == DEFAULT_VALUE
-    Timeout.timeout(timeout) do
-      record_dir ||= ENV["DEBUG"] ? "tmp" : nil
-      search = CodeSearch.new(source, record_dir: record_dir).call
-    end
-
-    blocks = search.invalid_blocks
-    DisplayInvalidBlocks.new(
-      io: io,
-      blocks: blocks,
-      filename: filename,
-      terminal: terminal,
-      code_lines: search.code_lines
-    ).call
-  rescue Timeout::Error => e
-    io.puts "Search timed out DEAD_END_TIMEOUT=#{timeout}, run with DEBUG=1 for more info"
-    io.puts e.backtrace.first(3).join($/)
-  end
-
-  # Used for counting spaces
-  module SpaceCount
-    def self.indent(string)
-      string.split(/\S/).first&.length || 0
-    end
-  end
-
-  # This will tell you if the `code_lines` would be valid
-  # if you removed the `without_lines`. In short it's a
-  # way to detect if we've found the lines with syntax errors
-  # in our document yet.
-  #
-  #   code_lines = [
-  #     CodeLine.new(line: "def foo\n",   index: 0)
-  #     CodeLine.new(line: "  def bar\n", index: 1)
-  #     CodeLine.new(line: "end\n",       index: 2)
-  #   ]
-  #
-  #   DeadEnd.valid_without?(
-  #     without_lines: code_lines[1],
-  #     code_lines: code_lines
-  #   )                                    # => true
-  #
-  #   DeadEnd.valid?(code_lines) # => false
-  def self.valid_without?(without_lines:, code_lines:)
-    lines = code_lines - Array(without_lines).flatten
-
-    if lines.empty?
-      true
-    else
-      valid?(lines)
-    end
-  end
-
-  def self.invalid?(source)
-    source = source.join if source.is_a?(Array)
-    source = source.to_s
-
-    Ripper.new(source).tap(&:parse).error?
-  end
-
-  # Returns truthy if a given input source is valid syntax
-  #
-  #   DeadEnd.valid?(<<~EOM) # => true
-  #     def foo
-  #     end
-  #   EOM
-  #
-  #   DeadEnd.valid?(<<~EOM) # => false
-  #     def foo
-  #       def bar # Syntax error here
-  #     end
-  #   EOM
-  #
-  # You can also pass in an array of lines and they'll be
-  # joined before evaluating
-  #
-  #   DeadEnd.valid?(
-  #     [
-  #       "def foo\n",
-  #       "end\n"
-  #     ]
-  #   ) # => true
-  #
-  #   DeadEnd.valid?(
-  #     [
-  #       "def foo\n",
-  #       "  def bar\n", # Syntax error here
-  #       "end\n"
-  #     ]
-  #   ) # => false
-  #
-  # As an FYI the CodeLine class instances respond to `to_s`
-  # so passing a CodeLine in as an object or as an array
-  # will convert it to it's code representation.
-  def self.valid?(source)
-    !invalid?(source)
-  end
-end
-
-# Integration
-require_relative "dead_end/cli"
-require_relative "dead_end/auto"
-
-# Core logic
-require_relative "dead_end/code_search"
-require_relative "dead_end/code_frontier"
-require_relative "dead_end/explain_syntax"
-require_relative "dead_end/clean_document"
-
-# Helpers
-require_relative "dead_end/lex_all"
-require_relative "dead_end/code_line"
-require_relative "dead_end/code_block"
-require_relative "dead_end/block_expand"
-require_relative "dead_end/ripper_errors"
-require_relative "dead_end/insertion_sort"
-require_relative "dead_end/around_block_scan"
-require_relative "dead_end/pathname_from_message"
-require_relative "dead_end/display_invalid_blocks"
-require_relative "dead_end/parse_blocks_from_indent_line"
+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.0.3
+  version: 3.1.2
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-17 00:00:00.000000000 Z
+date: 2022-05-18 00:00:00.000000000 Z
 dependencies: []
 description: When you get an "unexpected end" in your syntax this gem helps you find
   it
@@ -36,6 +36,7 @@ files:
 - dead_end.gemspec
 - exe/dead_end
 - lib/dead_end.rb
+- lib/dead_end/api.rb
 - lib/dead_end/around_block_scan.rb
 - lib/dead_end/auto.rb
 - lib/dead_end/block_expand.rb
@@ -46,16 +47,19 @@ files:
 - lib/dead_end/code_frontier.rb
 - lib/dead_end/code_line.rb
 - lib/dead_end/code_search.rb
+- lib/dead_end/core_ext.rb
 - 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:
@@ -78,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.14
 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