dead_end 3.0.1 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c232ccfce002bd3a79d6a5508ea46b27684a9a0ae2bb5d6f843d49e5ba59c0ac
-  data.tar.gz: 745847314c5c3ff09cb85b525a5d583f89c1c597e1f5b785ed54e01299bb72c4
+  metadata.gz: 64abeaee0636d3ded8df0f0dc124674a70f954287b37302dff7151f04b746557
+  data.tar.gz: 02e6eea73a9e9e832b898f9294c1ce3f7f38f9b8996554a8f6527abf7027d115
 SHA512:
-  metadata.gz: c49f5b58a7a2f222606a01efc3256a2a0eceade66ff6e46f7c15172cf972a48aa4b6d55212eb714ad69dde1b6d80e91cf8589a9b7026ad2b3e9baafabb8c2e6c
-  data.tar.gz: f70fc9947a92d8de2d8f05e08ab803a791c9fc396f03a0bed812b0a88bdb74af33658b23ebdf148adbc716cc41870bee8fabe57c3ae62bd6c9e9b063717f0bbc
+  metadata.gz: e7381458f44ef92f5053ac3171ac8bc59e89a805d793dde1c48ce1eda855dcea624ef6dc7a1faa3da9c20abc53983675fc66a7b08e3e02893801b4b4ff0edf65
+  data.tar.gz: 8b92dee56fac32777f31b76e25a0b778b2a4ffa1ff6914f24ef835bbf5ab79898f4a3a5607a9bebc641f86b05f2a88224504f0f8aaab83c3262b1d067ea32af0

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,17 @@ jobs:
       - ruby/install-deps
       - <<: *unit
 
+  "ruby-3-1":
+    docker:
+      - image: 'cimg/base:stable'
+    steps:
+      - checkout
+      - ruby/install:
+          version: '3.1.0-preview1'
+      - run: ruby -v
+      - ruby/install-deps
+      - <<: *unit
+
   "lint":
     docker:
       - image: circleci/ruby:3.0
@@ -61,4 +72,5 @@ workflows:
       - "ruby-2-6"
       - "ruby-2-7"
       - "ruby-3-0"
+      - "ruby-3-1"
       - "lint"

data/CHANGELOG.md

@@ -1,11 +1,33 @@
 ## HEAD (unreleased)
 
+## 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)
+- Fix explanation involving shorthand syntax for literals like `%w[]` and `%Q{}` (https://github.com/zombocom/dead_end/pull/116)
+
+## 3.0.2
+
+- Fix windows filename detection (https://github.com/zombocom/dead_end/pull/114)
+- Update links on readme and code of conduct (https://github.com/zombocom/dead_end/pull/107)
+
 ## 3.0.1
 
 - Fix CLI parsing when flags come before filename (https://github.com/zombocom/dead_end/pull/102)
 
 ## 3.0.0
 
+- [Breaking] CLI now outputs to STDOUT instead of STDERR (https://github.com/zombocom/dead_end/pull/98)
 - [Breaking] Remove previously deprecated `require "dead_end/fyi"` interface (https://github.com/zombocom/dead_end/pull/94)
 - Fix double output bug (https://github.com/zombocom/dead_end/pull/99)
 - Fix bug causing poor results (fix #95, fix #88) (https://github.com/zombocom/dead_end/pull/96)

data/CODE_OF_CONDUCT.md

@@ -68,7 +68,7 @@ members of the project's leadership.
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [https://contributor-covenant.org/version/1/4][version]
+available at [https://contributor-covenant.org/version/1/4/code-of-conduct/][version]
 
 [homepage]: https://contributor-covenant.org
-[version]: https://contributor-covenant.org/version/1/4/
+[version]: https://contributor-covenant.org/version/1/4/code-of-conduct/

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dead_end (3.0.1)
+    dead_end (3.1.1)
 
 GEM
   remote: https://rubygems.org/
@@ -62,4 +62,4 @@ DEPENDENCIES
   standard
 
 BUNDLED WITH
-   2.2.30
+   2.3.4

data/README.md

@@ -45,6 +45,13 @@ To get the CLI and manually search for syntax errors (but not automatically anno
 
 This gives you the CLI command `$ dead_end` for more info run `$ dead_end --help`.
 
+## Editor integration
+
+An extension is available for VSCode:
+
+- Extension: https://marketplace.visualstudio.com/items?itemName=Zombocom.dead-end-vscode
+- GitHub: https://github.com/zombocom/dead_end-vscode
+
 ## What syntax errors does it handle?
 
 Dead end will fire against all syntax errors and can isolate any syntax error. In addition, dead_end attempts to produce human readable descriptions of what needs to be done to resolve the issue. For example:
@@ -159,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_en/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.
@@ -195,7 +212,7 @@ $ qcachegrind tmp/last/profile.callgrind.out.<numbers>
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/zombocom/dead_end. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/zombocom/dead_end/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/zombocom/dead_end. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/zombocom/dead_end/blob/main/CODE_OF_CONDUCT.md).
 
 
 ## License
@@ -204,4 +221,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the DeadEnd project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/zombocom/dead_end/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the DeadEnd project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/zombocom/dead_end/blob/main/CODE_OF_CONDUCT.md).

data/lib/dead_end/api.rb

@@ -0,0 +1,196 @@
+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: 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
+
+  # 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 "insertion_sort"
+require_relative "around_block_scan"
+require_relative "pathname_from_message"
+require_relative "display_invalid_blocks"
+require_relative "parse_blocks_from_indent_line"

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/clean_document.rb

@@ -85,8 +85,8 @@ module DeadEnd
   #
   class CleanDocument
     def initialize(source:)
-      @source = clean_sweep(source: source)
-      @document = CodeLine.from_source(@source)
+      lines = clean_sweep(source: source)
+      @document = CodeLine.from_source(lines.join, lines: lines)
     end
 
     # Call all of the document "cleaners"
@@ -161,7 +161,7 @@ module DeadEnd
         else
           line
         end
-      end.join
+      end
     end
 
     # Smushes all heredoc lines into one line

data/lib/dead_end/code_frontier.rb

@@ -54,6 +54,8 @@ module DeadEnd
       @code_lines = code_lines
       @frontier = InsertionSort.new
       @unvisited_lines = @code_lines.sort_by(&:indent_index)
+      @visited_lines = {}
+
       @has_run = false
       @check_next = true
     end
@@ -128,7 +130,13 @@ module DeadEnd
     end
 
     def register_indent_block(block)
-      @unvisited_lines -= block.lines
+      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
       self
     end
 

data/lib/dead_end/code_line.rb

@@ -26,9 +26,10 @@ module DeadEnd
 
     # Returns an array of CodeLine objects
     # from the source string
-    def self.from_source(source)
-      lex_array_for_line = LexAll.new(source: source).each_with_object(Hash.new { |h, k| h[k] = [] }) { |lex, hash| hash[lex.line] << lex }
-      source.lines.map.with_index do |line, index|
+    def self.from_source(source, lines: nil)
+      lines ||= source.lines
+      lex_array_for_line = LexAll.new(source: source, source_lines: lines).each_with_object(Hash.new { |h, k| h[k] = [] }) { |lex, hash| hash[lex.line] << lex }
+      lines.map.with_index do |line, index|
         CodeLine.new(
           line: line,
           index: index,
@@ -42,28 +43,20 @@ module DeadEnd
       @lex = lex
       @line = line
       @index = index
-      @original = line.freeze
+      @original = line
       @line_number = @index + 1
+      strip_line = line.dup
+      strip_line.lstrip!
 
-      if line.strip.empty?
+      if strip_line.empty?
         @empty = true
         @indent = 0
       else
         @empty = false
-        @indent = SpaceCount.indent(line)
+        @indent = line.length - strip_line.length
       end
 
-      kw_count = 0
-      end_count = 0
-      @lex.each do |lex|
-        kw_count += 1 if lex.is_kw?
-        end_count += 1 if lex.is_end?
-      end
-
-      kw_count -= oneliner_method_count
-
-      @is_kw = (kw_count - end_count) > 0
-      @is_end = (end_count - kw_count) > 0
+      set_kw_end
     end
 
     # Used for stable sort via indentation level
@@ -179,8 +172,7 @@ module DeadEnd
     #
     # For some reason this introduces `on_ignore_newline` but with BEG type
     def ignore_newline_not_beg?
-      lex_value = lex.detect { |l| l.type == :on_ignored_nl }
-      !!(lex_value && !lex_value.expr_beg?)
+      @ignore_newline_not_beg
     end
 
     # Determines if the given line has a trailing slash
@@ -206,11 +198,22 @@ module DeadEnd
     #
     #   ENDFN -> BEG (token = '=' ) -> END
     #
-    private def oneliner_method_count
+    private def set_kw_end
       oneliner_count = 0
       in_oneliner_def = nil
 
+      kw_count = 0
+      end_count = 0
+
+      @ignore_newline_not_beg = false
       @lex.each do |lex|
+        kw_count += 1 if lex.is_kw?
+        end_count += 1 if lex.is_end?
+
+        if lex.type == :on_ignored_nl
+          @ignore_newline_not_beg = !lex.expr_beg?
+        end
+
         if in_oneliner_def.nil?
           in_oneliner_def = :ENDFN if lex.state.allbits?(Ripper::EXPR_ENDFN)
         elsif lex.state.allbits?(Ripper::EXPR_ENDFN)
@@ -227,7 +230,10 @@ module DeadEnd
         end
       end
 
-      oneliner_count
+      kw_count -= oneliner_count
+
+      @is_kw = (kw_count - end_count) > 0
+      @is_end = (end_count - kw_count) > 0
     end
   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/left_right_lex_count.rb

@@ -61,6 +61,17 @@ module DeadEnd
         # ^^^
         # Means it's a string or a symbol `"{"` rather than being
         # part of a data structure (like a hash) `{ a: b }`
+        # ignore it.
+      when :on_words_beg, :on_symbos_beg, :on_qwords_beg,
+           :on_qsymbols_beg, :on_regexp_beg, :on_tstring_beg
+        # ^^^
+        # Handle shorthand syntaxes like `%Q{ i am a string }`
+        #
+        # The start token will be the full thing `%Q{` but we
+        # need to count it as if it's a `{`. Any token
+        # can be used
+        char = lex.token[-1]
+        @count_for_char[char] += 1 if @count_for_char.key?(char)
       when :on_embexpr_beg
         # ^^^
         # Embedded string expressions like `"#{foo} <-embed"`

data/lib/dead_end/lex_all.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeadEnd
   # Ripper.lex is not guaranteed to lex the entire source document
   #
@@ -8,20 +10,25 @@ module DeadEnd
   class LexAll
     include Enumerable
 
-    def initialize(source:)
-      @lex = Ripper.lex(source)
-      lineno = @lex.last.first.first + 1
-      source_lines = source.lines
-      last_lineno = source_lines.count
+    def initialize(source:, source_lines: nil)
+      @lex = Ripper::Lexer.new(source, "-", 1).parse.sort_by(&:pos)
+      lineno = @lex.last.pos.first + 1
+      source_lines ||= source.lines
+      last_lineno = source_lines.length
 
       until lineno >= last_lineno
         lines = source_lines[lineno..-1]
 
-        @lex.concat(Ripper.lex(lines.join, "-", lineno + 1))
-        lineno = @lex.last.first.first + 1
+        @lex.concat(
+          Ripper::Lexer.new(lines.join, "-", lineno + 1).parse.sort_by(&:pos)
+        )
+        lineno = @lex.last.pos.first + 1
       end
 
-      @lex.map! { |(line, _), type, token, state| LexValue.new(line, type, token, 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeadEnd
   # Value object for accessing lex values
   #
@@ -13,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"
@@ -39,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/pathname_from_message.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Converts a SyntaxError message to a path
+  #
+  # Handles the case where the filename has a colon in it
+  # such as on a windows file system: https://github.com/zombocom/dead_end/issues/111
+  #
+  # Example:
+  #
+  #    message = "/tmp/scratch:2:in `require_relative': /private/tmp/bad.rb:1: syntax error, unexpected `end' (SyntaxError)"
+  #    puts PathnameFromMessage.new(message).call.name
+  #    # => "/tmp/scratch.rb"
+  #
+  class PathnameFromMessage
+    attr_reader :name
+
+    def initialize(message, io: $stderr)
+      @line = message.lines.first
+      @parts = @line.split(":")
+      @guess = []
+      @name = nil
+      @io = io
+    end
+
+    def call
+      until stop?
+        @guess << @parts.shift
+        @name = Pathname(@guess.join(":"))
+      end
+
+      if @parts.empty?
+        @io.puts "DeadEnd: Could not find filename from #{@line.inspect}"
+        @name = nil
+      end
+
+      self
+    end
+
+    def stop?
+      return true if @parts.empty?
+      return false if @guess.empty?
+
+      @name&.exist?
+    end
+  end
+end

data/lib/dead_end/ripper_errors.rb

@@ -18,6 +18,12 @@ module DeadEnd
       @errors << msg
     end
 
+    alias_method :on_alias_error, :on_parse_error
+    alias_method :on_assign_error, :on_parse_error
+    alias_method :on_class_name_error, :on_parse_error
+    alias_method :on_param_error, :on_parse_error
+    alias_method :compile_error, :on_parse_error
+
     def call
       @run_once ||= begin
         @errors = []

data/lib/dead_end/version.rb

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

data/lib/dead_end.rb

@@ -1,159 +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)
-    filename = e.message.split(":").first
-    $stderr.sync = true
-
-    call(
-      source: Pathname(filename).read,
-      filename: filename
-    )
-
-    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
-
-require_relative "dead_end/code_line"
-require_relative "dead_end/code_block"
-require_relative "dead_end/code_search"
-require_relative "dead_end/code_frontier"
-require_relative "dead_end/clean_document"
-
-require_relative "dead_end/lex_all"
-require_relative "dead_end/block_expand"
-require_relative "dead_end/insertion_sort"
-require_relative "dead_end/around_block_scan"
-require_relative "dead_end/ripper_errors"
-require_relative "dead_end/display_invalid_blocks"
-require_relative "dead_end/parse_blocks_from_indent_line"
-
-require_relative "dead_end/explain_syntax"
-
-require_relative "dead_end/auto"
-require_relative "dead_end/cli"
+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.1
+  version: 3.1.1
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-04 00:00:00.000000000 Z
+date: 2022-01-04 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,6 +47,7 @@ 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
@@ -54,6 +56,7 @@ files:
 - 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/ripper_errors.rb
 - lib/dead_end/version.rb
 homepage: https://github.com/zombocom/dead_end.git
@@ -77,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Find syntax errors in your source in a snap