dead_end 1.0.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f04f0b2618c6787e30d722b387fe19eb026923d588abf15d676566a3496970f7
-  data.tar.gz: 9ea352efa6c3622eb9097a33f79db08219e4d156ea5ccbcfab3777e8e176472e
+  metadata.gz: 83ee512040b172db6ab10b5bc6220e856734653bb4c033291a5b2d6210485996
+  data.tar.gz: b0812e0b2f605101c0bdef7f5d08886d404e5c02f4e28bb11e982e6cabef4636
 SHA512:
-  metadata.gz: 1dd513cdeba2f2e560eacd2113660e77f3eea9c0f0947629fe5c0e7352d2fcbf2178107fead38d7e7a32ead25e803b324809863af151eff70fb9831ffd43c8ec
-  data.tar.gz: e377f56853a8fd6e72afd9bb262965876dfa0242158a7a7327523825a3e1c008173bf1c2d6b1bf25b5a79c51711326e6cae098cfe4b363407929ccbf7ae8ad78
+  metadata.gz: 69cd9208b68cd671f90fe82ef1cf69e2f7037286360665b648690d51e0e9206f4e53abe3c4da755c2fcec08ed76261ca85a7e17c2dfcef7589880d149c33daf3
+  data.tar.gz: b78698db009e17b234da6aa1cbc185b9c5d391e9466685e823911ed2f725b02c0e2d2d14a79fed02a3e907cbd84d96314fb335ea80aa6cc78adf2d1ba8fff4b8

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## HEAD (unreleased)
 
+## 1.1.2
+
+- Namespace Kernel method aliases (https://github.com/zombocom/dead_end/pull/51)
+
+## 1.1.1
+
+- Safer NoMethodError annotation (https://github.com/zombocom/dead_end/pull/48)
+
+## 1.1.0
+
+- Annotate NoMethodError in non-production environments (https://github.com/zombocom/dead_end/pull/46)
+- Do not count trailing if/unless as a keyword (https://github.com/zombocom/dead_end/pull/44)
+
+## 1.0.2
+
+- Fix bug where empty lines were interpreted to have a zero indentation (https://github.com/zombocom/dead_end/pull/39)
+- Better results when missing "end" comes at the end of a capturing block (such as a class or module definition) (https://github.com/zombocom/dead_end/issues/32)
+
+## 1.0.1
+
+- Fix performance issue when evaluating multiple block combinations (https://github.com/zombocom/dead_end/pull/35)
+
 ## 1.0.0
 
 - Gem name changed from `syntax_search` to `dead_end` (https://github.com/zombocom/syntax_search/pull/30)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dead_end (1.0.0)
+    dead_end (1.1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -33,4 +33,4 @@ DEPENDENCIES
   stackprof
 
 BUNDLED WITH
-   2.1.4
+   2.2.3

data/README.md

@@ -1,6 +1,6 @@
 # DeadEnd
 
-An AI powered library to find syntax errors in your source code:
+An error in your code forces you to stop. DeadEnd helps you find those errors to get you back on your way faster.
 
     DeadEnd: Unmatched `end` detected
 
@@ -18,7 +18,7 @@ An AI powered library to find syntax errors in your source code:
 
 ## Installation in your codebase
 
-To automatically search syntax errors when they happen, add this to your Gemfile:
+To automatically annotate errors when they happen, add this to your Gemfile:
 
 ```ruby
 gem 'dead_end'
@@ -44,7 +44,7 @@ If you're using rspec add this to your `.rspec` file:
 
 ## Install the CLI
 
-To get the CLI and manually search for syntax errors, install the gem:
+To get the CLI and manually search for syntax errors (but not automatically annotate them), you can manually install the gem:
 
     $ gem install dead_end
 
@@ -54,7 +54,7 @@ This gives you the CLI command `$ dead_end` for more info run `$ dead_end --help
 
 - Missing `end`:
 
-```
+```ruby
 class Dog
   def bark
     puts "bark"
@@ -68,7 +68,7 @@ end
 
 - Unexpected `end`
 
-```
+```ruby
 class Dog
   def speak
     @sounds.each |sound| # Note the missing `do` here
@@ -81,6 +81,21 @@ end
 
 As well as unmatched `|` and unmatched `}`. These errors can be time consuming to debug because Ruby often only tells you the last line in the file. The command `ruby -wc path/to/file.rb` can narrow it down a little bit, but this library does a better job.
 
+## What other errors does it handle?
+
+In addition to syntax errors, the NoMethodError is annotated to show the line where the error occured, and the surrounding context:
+
+```
+scratch.rb:7:in `call': undefined method `upcase' for nil:NilClass (NoMethodError)
+
+
+  1  class Pet
+  6    def call
+❯ 7      puts "Come here #{@neam.upcase}"
+  8    end
+  9  end
+```
+
 ## Sounds cool, but why isn't this baked into Ruby directly?
 
 I would love to get something like this directly in Ruby, but I first need to prove it's useful. The `did_you_mean` functionality started as a gem that was eventually adopted by a bunch of people and then Ruby core liked it enough that they included it in the source. The goal of this gem is to:
@@ -90,7 +105,7 @@ I would love to get something like this directly in Ruby, but I first need to pr
 
 ## Artificial Inteligence?
 
-This library uses a goal-seeking algorithm similar to that of a path-finding search. For more information [read the blog post about how it works under the hood](https://schneems.com/2020/12/01/squash-unexpectedend-errors-with-syntaxsearch/).
+This library uses a goal-seeking algorithm for syntax error detection similar to that of a path-finding search. For more information [read the blog post about how it works under the hood](https://schneems.com/2020/12/01/squash-unexpectedend-errors-with-syntaxsearch/).
 
 ## How does it detect syntax error locations?
 

data/lib/dead_end/around_block_scan.rb

@@ -153,11 +153,20 @@ module DeadEnd
       self.scan_while {|line| line.not_empty? && line.indent >= @orig_indent }
     end
 
+    def next_up
+      @code_lines[before_index.pred]
+    end
+
+    def next_down
+      @code_lines[after_index.next]
+    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
+      before_after_indent = []
+      before_after_indent << (next_up&.indent || 0)
+      before_after_indent << (next_down&.indent || 0)
 
-      indent = [before_indent, after_indent].min
+      indent = before_after_indent.min
       self.scan_while {|line| line.not_empty? && line.indent >= indent }
 
       self
@@ -183,11 +192,11 @@ module DeadEnd
     end
 
     private def before_lines
-      @code_lines[0...@orig_before_index]
+      @code_lines[0...@orig_before_index] || []
     end
 
     private def after_lines
-      @code_lines[@orig_after_index.next..-1]
+      @code_lines[after_index.next..-1] || []
     end
   end
 end

data/lib/dead_end/auto.rb

@@ -1,29 +1,31 @@
+# frozen_string_literal: true
+#
 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
+  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)
-    original_load(file)
+    dead_end_original_load(file)
   rescue SyntaxError => e
     DeadEnd.handle_error(e)
   end
 
   def require(file)
-    original_require(file)
+    dead_end_original_require(file)
   rescue SyntaxError => e
     DeadEnd.handle_error(e)
   end
 
   def require_relative(file)
     if Pathname.new(file).absolute?
-      original_require file
+      dead_end_original_require file
     else
-      original_require File.expand_path("../#{file}", caller_locations(1, 1)[0].absolute_path)
+      dead_end_original_require File.expand_path("../#{file}", caller_locations(1, 1)[0].absolute_path)
     end
   rescue SyntaxError => e
     DeadEnd.handle_error(e)
@@ -49,3 +51,52 @@ class Object
   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

data/lib/dead_end/capture_code_context.rb

@@ -35,20 +35,9 @@ module DeadEnd
 
     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
+        capture_last_end_same_indent(block)
+        capture_before_after_kws(block)
+        capture_falling_indent(block)
       end
 
       @lines_to_output.select!(&:not_empty?)
@@ -58,5 +47,70 @@ module DeadEnd
 
       return @lines_to_output
     end
+
+    def capture_falling_indent(block)
+      AroundBlockScan.new(
+        block: block,
+        code_lines: @code_lines,
+      ).on_falling_indent do |line|
+        @lines_to_output << line
+      end
+    end
+
+    def capture_before_after_kws(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)
+    end
+
+    # Problems heredocs are back in play
+    def capture_last_end_same_indent(block)
+      start_index = block.visible_lines.first.index
+      lines = @code_lines[start_index..block.lines.last.index]
+      kw_end_lines = lines.select {|line| line.indent == block.current_indent && (line.is_end? || line.is_kw?) }
+
+
+      # TODO handle case of heredocs showing up here
+      #
+      # Due to https://github.com/zombocom/dead_end/issues/32
+      # There's a special case where a keyword right before the last
+      # end of a valid block accidentally ends up identifying that the problem
+      # was with the block instead of before it. To handle that
+      # special case, we can re-parse back through the internals of blocks
+      # and if they have mis-matched keywords and ends show the last one
+      end_lines = kw_end_lines.select(&:is_end?)
+      end_lines.each_with_index  do |end_line, i|
+        start_index = i.zero? ? 0 : end_lines[i-1].index
+        end_index = end_line.index - 1
+        lines = @code_lines[start_index..end_index]
+
+        stop_next = false
+        kw_count = 0
+        end_count = 0
+        lines = lines.reverse.take_while do |line|
+          next false if stop_next
+
+          end_count += 1 if line.is_end?
+          kw_count += 1 if line.is_kw?
+
+          stop_next = true if !kw_count.zero? && kw_count >= end_count
+          true
+        end.reverse
+
+        next unless kw_count > end_count
+
+        lines = lines.select {|line| line.is_kw? || line.is_end? }
+
+        next if lines.empty?
+
+        @lines_to_output << end_line
+        @lines_to_output << lines.first
+        @lines_to_output << lines.last
+      end
+    end
   end
 end

data/lib/dead_end/code_block.rb

@@ -17,10 +17,12 @@ module DeadEnd
   #
   #
   class CodeBlock
+    UNSET = Object.new.freeze
     attr_reader :lines
 
     def initialize(lines: [])
       @lines = Array(lines)
+      @valid = UNSET
     end
 
     def visible_lines
@@ -68,7 +70,8 @@ module DeadEnd
     end
 
     def valid?
-      DeadEnd.valid?(self.to_s)
+      return @valid if @valid != UNSET
+      @valid = DeadEnd.valid?(self.to_s)
     end
 
     def to_s

data/lib/dead_end/code_frontier.rb

@@ -10,20 +10,20 @@ module DeadEnd
   # sorted and then the frontier can be filtered. Large blocks that totally contain a
   # smaller block will cause the smaller block to be evicted.
   #
-  #   CodeFrontier#<<
-  #   CodeFrontier#pop
+  #   CodeFrontier#<<(block) # Adds block to frontier
+  #   CodeFrontier#pop # Removes block from frontier
   #
   # ## Knowing where we can go
   #
-  # Internally it keeps track of an "indent hash" which is exposed via `next_indent_line`
+  # Internally it keeps track of "unvisited" lines which is exposed via `next_indent_line`
   # when called this will return a line of code with the most indentation.
   #
-  # This line of code can be used to build a CodeBlock via and then when that code block
-  # is added back to the frontier, then the lines in the code block are removed from the
-  # indent hash so we don't double-create the same block.
+  # This line of code can be used to build a CodeBlock and then when that code block
+  # is added back to the frontier, then the lines are removed from the
+  # "unvisited" so we don't double-create the same block.
   #
-  #   CodeFrontier#next_indent_line
-  #   CodeFrontier#register_indent_block
+  #   CodeFrontier#next_indent_line # Shows next line
+  #   CodeFrontier#register_indent_block(block) # Removes lines from unvisited
   #
   # ## Knowing when to stop
   #
@@ -42,13 +42,7 @@ module DeadEnd
     def initialize(code_lines: )
       @code_lines = code_lines
       @frontier = []
-      @indent_hash = {}
-      code_lines.each do |line|
-        next if line.empty?
-
-        @indent_hash[line.indent] ||= []
-        @indent_hash[line.indent] << line
-      end
+      @unvisited_lines = @code_lines.sort_by(&:indent_index)
     end
 
     def count
@@ -75,38 +69,31 @@ module DeadEnd
       return @frontier.pop
     end
 
-    def indent_hash_indent
-      @indent_hash.keys.sort.last
-    end
-
     def next_indent_line
-      indent = @indent_hash.keys.sort.last
-      @indent_hash[indent]&.first
+      @unvisited_lines.last
     end
 
     def expand?
       return false if @frontier.empty?
-      return true if @indent_hash.empty?
+      return true if @unvisited_lines.empty?
 
       frontier_indent = @frontier.last.current_indent
-      hash_indent = @indent_hash.keys.sort.last
+      unvisited_indent= next_indent_line.indent
 
       if ENV["DEBUG"]
         puts "```"
         puts @frontier.last.to_s
         puts "```"
         puts "  @frontier indent: #{frontier_indent}"
-        puts "  @hash indent:     #{hash_indent}"
+        puts "  @unvisited indent:     #{unvisited_indent}"
       end
 
-      frontier_indent >= hash_indent
+      # Expand all blocks before moving to unvisited lines
+      frontier_indent >= unvisited_indent
     end
 
     def register_indent_block(block)
-      block.lines.each do |line|
-        @indent_hash[line.indent]&.delete(line)
-      end
-      @indent_hash.select! {|k, v| !v.empty?}
+      @unvisited_lines -= block.lines
       self
     end
 
@@ -143,7 +130,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).detect do |block_array|
+      self.class.combination(@frontier.select(&:invalid?)).detect do |block_array|
         holds_all_syntax_errors?(block_array)
       end || []
     end

data/lib/dead_end/code_line.rb

@@ -31,14 +31,25 @@ module DeadEnd
   class CodeLine
     TRAILING_SLASH = ("\\" + $/).freeze
 
+    def self.parse(source)
+      source.lines.map.with_index do |line, index|
+        CodeLine.new(line: line, index: index)
+      end
+    end
+
     attr_reader :line, :index, :indent, :original_line
 
     def initialize(line: , index:)
       @original_line = line.freeze
       @line = @original_line
-      @empty = line.strip.empty?
+      if line.strip.empty?
+        @empty = true
+        @indent = 0
+      else
+        @empty = false
+        @indent = SpaceCount.indent(line)
+      end
       @index = index
-      @indent = SpaceCount.indent(line)
       @status = nil # valid, invalid, unknown
       @invalid = false
 
@@ -46,24 +57,29 @@ module DeadEnd
     end
 
     private def lex_detect!
-      lex = LexAll.new(source: line)
+      lex_array = LexAll.new(source: line)
       kw_count = 0
       end_count = 0
-      lex.each do |lex|
+      lex_array.each_with_index do |lex, index|
         next unless lex.type == :on_kw
 
         case lex.token
-        when 'def', 'case', 'for', 'begin', 'class', 'module', 'if', 'unless', 'while', 'until' , 'do'
+        when 'if', 'unless', 'while', 'until'
+          # Only count if/unless when it's not a "trailing" if/unless
+          # https://github.com/ruby/ruby/blob/06b44f819eb7b5ede1ff69cecb25682b56a1d60c/lib/irb/ruby-lex.rb#L374-L375
+          kw_count += 1 if !lex.expr_label?
+        when 'def', 'case', 'for', 'begin', 'class', 'module', 'do'
           kw_count += 1
         when 'end'
           end_count += 1
         end
       end
 
+      @is_comment = lex_array.detect {|lex| lex.type != :on_sp}&.type == :on_comment
+      return if @is_comment
       @is_kw = (kw_count - end_count) > 0
       @is_end = (end_count - kw_count) > 0
-      @is_comment = lex.detect {|lex| lex.type != :on_sp}&.type == :on_comment
-      @is_trailing_slash = lex.last.token == TRAILING_SLASH
+      @is_trailing_slash = lex_array.last.token == TRAILING_SLASH
     end
 
     alias :original :original_line
@@ -72,6 +88,10 @@ module DeadEnd
       @is_trailing_slash
     end
 
+    def indent_index
+      @indent_index ||= [indent, index]
+    end
+
     def <=>(b)
       self.index <=> b.index
     end
@@ -92,15 +112,6 @@ module DeadEnd
       @is_end
     end
 
-    def mark_invalid
-      @invalid = true
-      self
-    end
-
-    def marked_invalid?
-      @invalid
-    end
-
     def mark_invisible
       @line = ""
       self

data/lib/dead_end/code_search.rb

@@ -75,7 +75,7 @@ module DeadEnd
       record(block: block, name: name)
 
       if block.valid?
-        block.lines.each(&:mark_invisible)
+        block.mark_invisible
         frontier << block
       else
         frontier << block
@@ -92,7 +92,7 @@ module DeadEnd
 
     # Parses the most indented lines into blocks that are marked
     # and added to the frontier
-    def add_invalid_blocks
+    def visit_new_blocks
       max_indent = frontier.next_indent_line&.indent
 
       while (line = frontier.next_indent_line) && (line.indent == max_indent)
@@ -145,7 +145,7 @@ module DeadEnd
         if frontier.expand?
           expand_invalid_block
         else
-          add_invalid_blocks
+          visit_new_blocks
         end
       end
 

data/lib/dead_end/internals.rb

@@ -37,9 +37,10 @@ module DeadEnd
     raise e
   end
 
-  def self.call(source: , filename: , terminal: false, record_dir: nil, timeout: TIMEOUT_DEFAULT)
+  def self.call(source: , filename: , terminal: false, record_dir: nil, timeout: TIMEOUT_DEFAULT, io: $stderr)
     search = nil
     Timeout.timeout(timeout) do
+      record_dir ||= ENV["DEBUG"] ? "tmp" : nil
       search = CodeSearch.new(source, record_dir: record_dir).call
     end
 
@@ -50,10 +51,11 @@ module DeadEnd
       terminal: terminal,
       code_lines: search.code_lines,
       invalid_obj: invalid_type(source),
-      io: $stderr
+      io: io
     ).call
-  rescue Timeout::Error
-    $stderr.puts "Search timed out DEAD_END_TIMEOUT=#{timeout}, run with DEBUG=1 for more info"
+  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

data/lib/dead_end/lex_all.rb

@@ -21,7 +21,7 @@ module DeadEnd
         lineno = @lex.last&.first&.first + 1
       end
 
-      @lex.map! {|(line, _), type, token| LexValue.new(line, _, type, token) }
+      @lex.map! {|(line, _), type, token, state| LexValue.new(line, _, type, token, state) }
     end
 
     def each
@@ -47,11 +47,17 @@ module DeadEnd
     #  lex.type # => :on_indent
     #  lex.token # => "describe"
     class LexValue
-      attr_reader :line, :type, :token
-      def initialize(line, _, type, token)
+      attr_reader :line, :type, :token, :state
+
+      def initialize(line, _, type, token, state)
         @line = line
         @type = type
         @token = token
+        @state = state
+      end
+
+      def expr_label?
+        state.allbits?(Ripper::EXPR_LABEL)
       end
     end
   end

data/lib/dead_end/parse_blocks_from_indent_line.rb

@@ -40,7 +40,7 @@ module DeadEnd
         .skip(:hidden?)
         .scan_while {|line| line.indent >= target_line.indent }
 
-      neighbors = @code_lines[scan.before_index..scan.after_index]
+      neighbors = scan.code_block.lines
 
       until neighbors.empty?
         lines = [neighbors.pop]

data/lib/dead_end/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeadEnd
-  VERSION = "1.0.0"
+  VERSION = "1.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dead_end
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.2
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-10 00:00:00.000000000 Z
+date: 2021-01-11 00:00:00.000000000 Z
 dependencies: []
 description: When you get an "unexpected end" in your syntax this gem helps you find
   it