dead_end 1.1.7 → 3.1.1

data/lib/dead_end/{internals.rb → api.rb}

@@ -1,44 +1,67 @@
-# frozen_string_literal: true
-#
-# This is the top level file, but is moved to `internals`
-# so the top level file can instead enable the "automatic" behavior
-
 require_relative "version"
 
-require 'tmpdir'
-require 'stringio'
-require 'pathname'
-require 'ripper'
-require 'timeout'
+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
-  SEARCH_SOURCE_ON_ERROR_DEFAULT = true
-  TIMEOUT_DEFAULT = ENV.fetch("DEAD_END_TIMEOUT", 5).to_i
+  TIMEOUT_DEFAULT = ENV.fetch("DEAD_END_TIMEOUT", 1).to_i
 
-  def self.handle_error(e, search_source_on_error: SEARCH_SOURCE_ON_ERROR_DEFAULT)
-    raise e if !e.message.include?("end-of-input")
+  # 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
 
-    filename = e.message.split(":").first
+    file = PathnameFromMessage.new(e.message, io: io).call.name
+    raise e unless file
 
-    $stderr.sync = true
-    $stderr.puts "Run `$ dead_end #{filename}` for more options\n"
+    io.sync = true
 
-    if search_source_on_error
-      self.call(
-        source: Pathname(filename).read,
-        filename: filename,
-        terminal: true,
-      )
-    end
+    call(
+      io: io,
+      source: file.read,
+      filename: file
+    )
 
-    $stderr.puts ""
-    $stderr.puts ""
-    raise e
+    raise e if re_raise
   end
 
-  def self.call(source: , filename: , terminal: false, record_dir: nil, timeout: TIMEOUT_DEFAULT, io: $stderr)
+  # DeadEnd.call [Private]
+  #
+  # Main private interface
+  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
@@ -46,25 +69,33 @@ module DeadEnd
 
     blocks = search.invalid_blocks
     DisplayInvalidBlocks.new(
+      io: io,
       blocks: blocks,
       filename: filename,
       terminal: terminal,
-      code_lines: search.code_lines,
-      invalid_obj: invalid_type(source),
-      io: io
+      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
+  # 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
@@ -82,16 +113,19 @@ module DeadEnd
   #   )                                    # => true
   #
   #   DeadEnd.valid?(code_lines) # => false
-  def self.valid_without?(without_lines: , code_lines:)
+  def self.valid_without?(without_lines:, code_lines:)
     lines = code_lines - Array(without_lines).flatten
 
     if lines.empty?
-      return true
+      true
     else
-      return valid?(lines)
+      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
@@ -99,6 +133,8 @@ module DeadEnd
     Ripper.new(source).tap(&:parse).error?
   end
 
+  # DeadEnd.valid? [Private]
+  #
   # Returns truthy if a given input source is valid syntax
   #
   #   DeadEnd.valid?(<<~EOM) # => true
@@ -136,23 +172,25 @@ module DeadEnd
   def self.valid?(source)
     !invalid?(source)
   end
+end
 
+# Integration
+require_relative "cli"
 
-  def self.invalid_type(source)
-    WhoDisSyntaxError.new(source).call
-  end
-end
+# 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 "code_frontier"
-require_relative "display_invalid_blocks"
-require_relative "around_block_scan"
 require_relative "block_expand"
+require_relative "ripper_errors"
+require_relative "insertion_sort"
+require_relative "around_block_scan"
+require_relative "pathname_from_message"
+require_relative "display_invalid_blocks"
 require_relative "parse_blocks_from_indent_line"
-
-require_relative "code_search"
-require_relative "who_dis_syntax_error"
-require_relative "heredoc_block_parse"
-require_relative "lex_all"
-require_relative "trailing_slash_join"

data/lib/dead_end/around_block_scan.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-#
+
 module DeadEnd
   # This class is useful for exploring contents before and after
   # a block
@@ -9,10 +9,10 @@ module DeadEnd
   #
   # Example:
   #
-  #   def dog
-  #     puts "bark"
-  #     puts "bark"
-  #   end
+  #   def dog         # 1
+  #     puts "bark"   # 2
+  #     puts "bark"   # 3
+  #   end             # 4
   #
   #   scan = AroundBlockScan.new(
   #     code_lines: code_lines
@@ -22,13 +22,13 @@ module DeadEnd
   #   scan.scan_while { true }
   #
   #   puts scan.before_index # => 0
-  #   puts scan.after_index # => 3
+  #   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:)
+    def initialize(code_lines:, block:)
       @code_lines = code_lines
       @orig_before_index = block.lines.first.index
       @orig_after_index = block.lines.last.index
@@ -56,7 +56,7 @@ module DeadEnd
       end_count = 0
       @before_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_array.detect { |meth| line.send(meth) }
 
         kw_count += 1 if line.is_kw?
         end_count += 1 if line.is_end?
@@ -65,14 +65,14 @@ module DeadEnd
         end
 
         block.call(line)
-      end.reverse.first&.index
+      end.last&.index
 
       stop_next = false
       kw_count = 0
       end_count = 0
       @after_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_array.detect { |meth| line.send(meth) }
 
         kw_count += 1 if line.is_kw?
         end_count += 1 if line.is_end?
@@ -89,7 +89,7 @@ module DeadEnd
       lines = []
       kw_count = 0
       end_count = 0
-      before_lines.reverse.each do |line|
+      before_lines.reverse_each do |line|
         next if line.empty?
         break if line.indent < @orig_indent
         next if line.indent != @orig_indent
@@ -109,8 +109,6 @@ module DeadEnd
       kw_count = 0
       end_count = 0
       after_lines.each do |line|
-        # puts "line: #{line.number} #{line.original_line}, indent: #{line.indent}, #{line.empty?} #{line.indent == @orig_indent}"
-
         next if line.empty?
         break if line.indent < @orig_indent
         next if line.indent != @orig_indent
@@ -124,14 +122,13 @@ module DeadEnd
 
         lines << line
       end
-      lines.select! {|line| !line.is_comment? }
 
       lines
     end
 
     def on_falling_indent
       last_indent = @orig_indent
-      before_lines.reverse.each do |line|
+      before_lines.reverse_each do |line|
         next if line.empty?
         if line.indent < last_indent
           yield line
@@ -150,7 +147,7 @@ module DeadEnd
     end
 
     def scan_neighbors
-      self.scan_while {|line| line.not_empty? && line.indent >= @orig_indent }
+      scan_while { |line| line.not_empty? && line.indent >= @orig_indent }
     end
 
     def next_up
@@ -167,13 +164,14 @@ module DeadEnd
       before_after_indent << (next_down&.indent || 0)
 
       indent = before_after_indent.min
-      self.scan_while {|line| line.not_empty? && line.indent >= indent }
+      scan_while { |line| line.not_empty? && line.indent >= indent }
 
       self
     end
 
     def start_at_next_line
-      before_index; after_index
+      before_index
+      after_index
       @before_index -= 1
       @after_index += 1
       self

data/lib/dead_end/auto.rb

@@ -1,104 +1,6 @@
 # frozen_string_literal: true
-#
-require_relative "../dead_end/internals"
 
-# Monkey patch kernel to ensure that all `require` calls call the same
-# method
-module Kernel
-  module_function
+require_relative "../dead_end"
+require_relative "core_ext"
 
-  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
-
-# I honestly have no idea why this Object delegation is needed
-# I keep staring at bootsnap and it doesn't have to do this
-# is there a bug in their implementation they haven't caught or
-# am I doing something different?
-class Object
-  private
-  def load(path, wrap = false)
-    Kernel.load(path, wrap)
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
-  end
-
-  def require(path)
-    Kernel.require(path)
-  rescue SyntaxError => e
-    DeadEnd.handle_error(e)
-  end
-end
-
-module DeadEnd
-  IsProduction = -> {
-    ENV["RAILS_ENV"] == "production" || ENV["RACK_ENV"] == "production"
-  }
-end
-
-# Unlike a syntax error, a NoMethodError can occur hundreds or thousands of times and
-# chew up CPU and other resources. Since this is primarilly a "development" optimization
-# we can attempt to disable this behavior in a production context.
-if !DeadEnd::IsProduction.call
-  class NoMethodError
-    alias :dead_end_original_to_s :to_s
-
-    def to_s
-      return super if DeadEnd::IsProduction.call
-
-      file, line, _ = backtrace[0].split(":")
-      return super if !File.exist?(file)
-
-      index = line.to_i - 1
-      source = File.read(file)
-      code_lines = DeadEnd::CodeLine.parse(source)
-
-      block = DeadEnd::CodeBlock.new(lines: code_lines[index])
-      lines = DeadEnd::CaptureCodeContext.new(
-        blocks: block,
-        code_lines: code_lines
-      ).call
-
-      message = super.dup
-      message << $/
-      message << $/
-
-      message << DeadEnd::DisplayCodeWithLineNumbers.new(
-        lines: lines,
-        highlight_lines: block.lines,
-        terminal: self.class.to_tty?
-      ).call
-
-      message << $/
-      message
-    rescue => e
-      puts "DeadEnd Internal error: #{e.dead_end_original_to_s}"
-      puts "DeadEnd Internal backtrace:"
-      puts backtrace.map {|l| "    " + l }.join($/)
-      super
-    end
-  end
-end
+warn "Calling `require 'dead_end/auto'` is deprecated, please `require 'dead_end'` instead."

data/lib/dead_end/block_expand.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module DeadEnd
   # This class is responsible for taking a code block that exists
   # at a far indentaion and then iteratively increasing the block
@@ -30,7 +31,7 @@ module DeadEnd
   #      end
   #
   class BlockExpand
-    def initialize(code_lines: )
+    def initialize(code_lines:)
       @code_lines = code_lines
     end
 
@@ -43,7 +44,7 @@ module DeadEnd
     end
 
     def expand_indent(block)
-      block = AroundBlockScan.new(code_lines: @code_lines, block: block)
+      AroundBlockScan.new(code_lines: @code_lines, block: block)
         .skip(:hidden?)
         .stop_after_kw
         .scan_adjacent_indent
@@ -59,15 +60,15 @@ module DeadEnd
       # Slurp up empties
       if grab_empty
         scan = AroundBlockScan.new(code_lines: @code_lines, block: scan.code_block)
-          .scan_while {|line| line.empty? || line.hidden? }
+          .scan_while { |line| line.empty? || line.hidden? }
       end
 
       new_block = scan.code_block
 
       if block.lines == new_block.lines
-        return nil
+        nil
       else
-        return new_block
+        new_block
       end
     end
   end