dead_end 3.0.3 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88cc140d421e1df16009993e7d7438054dad7a6b6fec740496e92c06c0bc2f6d
-  data.tar.gz: ba736b1459f6c18aed62b566fa8e48ca6a4dd8379bc2dc2d99594c0daf136fb6
+  metadata.gz: f35aa207ae1ff3904d39f5c0ddca5b8a0f68ae157f5c0a999cd3f2f1530e461b
+  data.tar.gz: b08307eb152fc12b84493409bfd8a9b8f23905180ad5ed9168a58d152913bc6e
 SHA512:
-  metadata.gz: 3cf585c9f073344d6259478c239fd45b77a5fb7fd1c37c18d3d2a7cf91323b00750cccb18d666935ea20ce2c209137216304429a26aac0bf26fec7aa5440ff14
-  data.tar.gz: 8a818ac4001ce7ec01ae36c4c223f47c7686e111226718cf22e8e2ca9f00a0bb3f3ef6409ad703cb698a67dc62035225973f37ea5f527207c26e705acd4c8f33
+  metadata.gz: 02b4ec64732eea9dbb55594c130d2fade4838a855bf3366408a5846683c3d2866e21844c7d3a2797adc865e177e7edf3bffaad0b87f555627f75fcac3d2aa219
+  data.tar.gz: '029add7304c46c97a8a04b564f5798a2e5d43afe24472ae51268226e2dd5e71c56b9c48bf889232d4c3f2759b6edb7ea4c4f332688d6995ddaac0f7ec8ae5803'

data/.circleci/config.yml

@@ -1,6 +1,6 @@
 version: 2.1
 orbs:
-  ruby: circleci/ruby@1.1.2
+  ruby: circleci/ruby@1.2.0
 references:
   unit: &unit
     run:
@@ -45,6 +45,28 @@ jobs:
       - ruby/install-deps
       - <<: *unit
 
+  "ruby-3-1":
+    docker:
+      - image: 'cimg/base:stable'
+    steps:
+      - checkout
+      - ruby/install:
+          version: '3.1.2'
+      - run: ruby -v
+      - ruby/install-deps
+      - <<: *unit
+
+  "ruby-3-2":
+    docker:
+      - image: 'cimg/base:stable'
+    steps:
+      - checkout
+      - ruby/install:
+          version: '3.2.0-preview1'
+      - run: ruby -v
+      - ruby/install-deps
+      - <<: *unit
+
   "lint":
     docker:
       - image: circleci/ruby:3.0
@@ -61,4 +83,6 @@ workflows:
       - "ruby-2-6"
       - "ruby-2-7"
       - "ruby-3-0"
+      - "ruby-3-1"
+      - "ruby-3-2"
       - "lint"

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## HEAD (unreleased)
 
+## 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)
+
+## 3.1.0
+
+- Add support for Ruby 3.1 by updating `require_relative` logic (https://github.com/zombocom/dead_end/pull/120)
+- Requiring `dead_end/auto` is now deprecated please require `dead_end` instead (https://github.com/zombocom/dead_end/pull/119)
+- Requiring `dead_end/api` now loads code without monkeypatching core extensions (https://github.com/zombocom/dead_end/pull/119)
+- The interface `DeadEnd.handle_error` is declared public and stable (https://github.com/zombocom/dead_end/pull/119)
+
 ## 3.0.3
 
 - Expand explanations coming from additional Ripper errors (https://github.com/zombocom/dead_end/pull/117)

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.0.3)
+    dead_end (3.1.2)
 
 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.2.30
+   2.3.14

data/README.md

@@ -166,6 +166,16 @@ Here's an example:
 
 ![](assets/syntax_search.gif)
 
+## Use internals
+
+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):
+
+- `DeadEnd.handle_error(e)`
+
+Any other entrypoints are subject to change without warning. If you want to use an internal interface from `dead_end` not on this list, open an issue to explain your use case.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/dead_end.gemspec

@@ -1,6 +1,10 @@
 # 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"

data/lib/dead_end/api.rb

@@ -0,0 +1,198 @@
+require_relative "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
+
+  # DeadEnd.handle_error [Public]
+  #
+  # 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.
+  #
+  # Example:
+  #
+  #   begin
+  #     require 'bad_file'
+  #   rescue => e
+  #     DeadEnd.handle_error(e)
+  #   end
+  #
+  # By default it will re-raise the exception unless
+  # `re_raise: false`. The message output location
+  # can be configured using the `io: $stderr` input.
+  #
+  # If a valid filename cannot be determined, the original
+  # exception will be re-raised (even with
+  # `re_raise: false`).
+  def self.handle_error(e, re_raise: true, io: $stderr)
+    unless e.is_a?(SyntaxError)
+      io.puts("DeadEnd: Must pass a SyntaxError, got: #{e.class}")
+      raise e
+    end
+
+    file = PathnameFromMessage.new(e.message, io: io).call.name
+    raise e unless file
+
+    io.sync = true
+
+    call(
+      io: io,
+      source: file.read,
+      filename: file
+    )
+
+    raise e if re_raise
+  end
+
+  # DeadEnd.call [Private]
+  #
+  # Main private interface
+  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
+      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
+
+  # DeadEnd.record_dir [Private]
+  #
+  # Used to generate a unique directory to record
+  # search steps for debugging
+  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
+
+  # DeadEnd.valid_without? [Private]
+  #
+  # 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
+
+  # DeadEnd.invalid? [Private]
+  #
+  # Opposite of `DeadEnd.valid?`
+  def self.invalid?(source)
+    source = source.join if source.is_a?(Array)
+    source = source.to_s
+
+    Ripper.new(source).tap(&:parse).error?
+  end
+
+  # DeadEnd.valid? [Private]
+  #
+  # 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 "cli"
+
+# Core logic
+require_relative "code_search"
+require_relative "code_frontier"
+require_relative "explain_syntax"
+require_relative "clean_document"
+
+# Helpers
+require_relative "lex_all"
+require_relative "code_line"
+require_relative "code_block"
+require_relative "block_expand"
+require_relative "ripper_errors"
+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/auto.rb

@@ -1,35 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "../dead_end"
+require_relative "core_ext"
 
-# 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
-      dead_end_original_require File.expand_path("../#{file}", Kernel.caller_locations(1, 1)[0].absolute_path)
-    end
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
-  end
-end
+warn "Calling `require 'dead_end/auto'` is deprecated, please `require 'dead_end'` instead."

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