dead_end 1.0.0

data/exe/dead_end

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require "optparse"
+require_relative "../lib/dead_end.rb"
+
+options = {}
+options[:terminal] = true
+options[:record_dir] = ENV["DEAD_END_RECORD_DIR"]
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<~EOM
+    Usage: dead_end <file> [options]
+
+    Parses a ruby source file and searches for syntax error(s) such as
+    unexpected `end', expecting end-of-input.
+
+    Example:
+
+      $ dead_end dog.rb
+
+      # ...
+
+        ❯ 10  defdog
+        ❯ 15  end
+        ❯ 16
+
+    Env options:
+
+      DEAD_END_RECORD_DIR=<dir>
+
+      When enabled, records the steps used to search for a syntax error to the
+      given directory
+
+    Options:
+  EOM
+
+  opts.on("--help", "Help - displays this message") do |v|
+    puts opts
+    exit
+  end
+
+  opts.on("--record <dir>", "When enabled, records the steps used to search for a syntax error to the given directory") do |v|
+    options[:record_dir] = v
+  end
+
+  opts.on("--no-terminal", "Disable terminal highlighting") do |v|
+    options[:terminal] = false
+  end
+end
+parser.parse!
+
+file = ARGV[0]
+
+if file.nil? || file.empty?
+  # Display help if raw command
+  parser.parse! %w[--help]
+end
+
+file = Pathname(file)
+options[:record_dir] = "tmp" if ENV["DEBUG"]
+
+$stderr.puts "Record dir: #{options[:record_dir]}"  if options[:record_dir]
+
+DeadEnd.call(
+  source: file.read,
+  filename: file.expand_path,
+  terminal: options[:terminal],
+  record_dir: options[:record_dir]
+)

data/lib/dead_end.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "dead_end/internals"
+require_relative "dead_end/auto"

data/lib/dead_end/around_block_scan.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+#
+module DeadEnd
+  # This class is useful for exploring contents before and after
+  # a block
+  #
+  # It searches above and below the passed in block to match for
+  # whatever criteria you give it:
+  #
+  # Example:
+  #
+  #   def dog
+  #     puts "bark"
+  #     puts "bark"
+  #   end
+  #
+  #   scan = AroundBlockScan.new(
+  #     code_lines: code_lines
+  #     block: CodeBlock.new(lines: code_lines[1])
+  #   )
+  #
+  #   scan.scan_while { true }
+  #
+  #   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
+    end
+
+    def skip(name)
+      @skip_array << name
+      self
+    end
+
+    def stop_after_kw
+      @stop_after_kw = true
+      self
+    end
+
+    def scan_while(&block)
+      stop_next = false
+
+      kw_count = 0
+      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) }
+
+        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
+
+        block.call(line)
+      end.reverse.first&.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) }
+
+        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
+
+        block.call(line)
+      end.last&.index
+      self
+    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
+
+      lines.reverse!
+
+      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
+
+        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
+      lines.select! {|line| !line.is_comment? }
+
+      lines
+    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
+    end
+
+    def scan_neighbors
+      self.scan_while {|line| line.not_empty? && line.indent >= @orig_indent }
+    end
+
+    def scan_adjacent_indent
+      before_indent = @code_lines[@orig_before_index.pred]&.indent || 0
+      after_indent = @code_lines[@orig_after_index.next]&.indent || 0
+
+      indent = [before_indent, after_indent].min
+      self.scan_while {|line| line.not_empty? && line.indent >= indent }
+
+      self
+    end
+
+    def start_at_next_line
+      before_index; after_index
+      @before_index -= 1
+      @after_index += 1
+      self
+    end
+
+    def code_block
+      CodeBlock.new(lines: @code_lines[before_index..after_index])
+    end
+
+    def before_index
+      @before_index ||= @orig_before_index
+    end
+
+    def after_index
+      @after_index ||= @orig_after_index
+    end
+
+    private def before_lines
+      @code_lines[0...@orig_before_index]
+    end
+
+    private def after_lines
+      @code_lines[@orig_after_index.next..-1]
+    end
+  end
+end

data/lib/dead_end/auto.rb

@@ -0,0 +1,51 @@
+require_relative "../dead_end/internals"
+
+# Monkey patch kernel to ensure that all `require` calls call the same
+# method
+module Kernel
+  alias_method :original_require, :require
+  alias_method :original_require_relative, :require_relative
+  alias_method :original_load, :load
+
+  def load(file, wrap = false)
+    original_load(file)
+  rescue SyntaxError => e
+    DeadEnd.handle_error(e)
+  end
+
+  def require(file)
+    original_require(file)
+  rescue SyntaxError => e
+    DeadEnd.handle_error(e)
+  end
+
+  def require_relative(file)
+    if Pathname.new(file).absolute?
+      original_require file
+    else
+      original_require File.expand_path("../#{file}", 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
+

data/lib/dead_end/block_expand.rb

@@ -0,0 +1,74 @@
+# 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
+  # so that it captures everything within the same indentation block.
+  #
+  #   def dog
+  #     puts "bow"
+  #     puts "wow"
+  #   end
+  #
+  # block = BlockExpand.new(code_lines: code_lines)
+  #   .call(CodeBlock.new(lines: code_lines[1]))
+  #
+  # puts block.to_s
+  # # => puts "bow"
+  #      puts "wow"
+  #
+  #
+  # Once a code block has captured everything at a given indentation level
+  # then it will expand to capture surrounding indentation.
+  #
+  # block = BlockExpand.new(code_lines: code_lines)
+  #   .call(block)
+  #
+  # block.to_s
+  # # => def dog
+  #        puts "bow"
+  #        puts "wow"
+  #      end
+  #
+  class BlockExpand
+    def initialize(code_lines: )
+      @code_lines = code_lines
+    end
+
+    def call(block)
+      if (next_block = expand_neighbors(block, grab_empty: true))
+        return next_block
+      end
+
+      expand_indent(block)
+    end
+
+    def expand_indent(block)
+      block = AroundBlockScan.new(code_lines: @code_lines, block: block)
+        .skip(:hidden?)
+        .stop_after_kw
+        .scan_adjacent_indent
+        .code_block
+    end
+
+    def expand_neighbors(block, grab_empty: true)
+      scan = AroundBlockScan.new(code_lines: @code_lines, block: block)
+        .skip(:hidden?)
+        .stop_after_kw
+        .scan_neighbors
+
+      # 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
+        return nil
+      else
+        return new_block
+      end
+    end
+  end
+end

data/lib/dead_end/capture_code_context.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module DeadEnd
+
+  # Given a block, this method will capture surrounding
+  # code to give the user more context for the location of
+  # the problem.
+  #
+  # Return is an array of CodeLines to be rendered.
+  #
+  # Surrounding code is captured regardless of visible state
+  #
+  #   puts block.to_s # => "def bark"
+  #
+  #   context = CaptureCodeContext.new(
+  #     blocks: block,
+  #     code_lines: code_lines
+  #   )
+  #
+  #   puts context.call.join
+  #   # =>
+  #     class Dog
+  #       def bark
+  #     end
+  #
+  class CaptureCodeContext
+    attr_reader :code_lines
+
+    def initialize(blocks: , code_lines:)
+      @blocks = Array(blocks)
+      @code_lines = code_lines
+      @visible_lines = @blocks.map(&:visible_lines).flatten
+      @lines_to_output = @visible_lines.dup
+    end
+
+    def call
+      @blocks.each do |block|
+        around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
+          .start_at_next_line
+          .capture_neighbor_context
+
+        around_lines -= block.lines
+
+        @lines_to_output.concat(around_lines)
+
+        AroundBlockScan.new(
+          block: block,
+          code_lines: @code_lines,
+        ).on_falling_indent do |line|
+          @lines_to_output << line
+        end
+      end
+
+      @lines_to_output.select!(&:not_empty?)
+      @lines_to_output.select!(&:not_comment?)
+      @lines_to_output.uniq!
+      @lines_to_output.sort!
+
+      return @lines_to_output
+    end
+  end
+end