dead_end 2.0.1 → 3.0.2

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,22 @@ 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) }
+      @lex.map! { |elem| LexValue.new(elem.pos.first, elem.event, elem.tok, elem.state) }
     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
   #

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Capture parse errors from ripper
+  #
+  # Example:
+  #
+  #   puts RipperErrors.new(" def foo").call.errors
+  #   # => ["syntax error, unexpected end-of-input, expecting ';' or '\\n'"]
+  class RipperErrors < Ripper
+    attr_reader :errors
+
+    # Comes from ripper, called
+    # on every parse error, msg
+    # is a string
+    def on_parse_error(msg)
+      @errors ||= []
+      @errors << msg
+    end
+
+    def call
+      @run_once ||= begin
+        @errors = []
+        parse
+        true
+      end
+      self
+    end
+  end
+end

data/lib/dead_end/version.rb

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

data/lib/dead_end.rb

@@ -1,4 +1,164 @@
 # frozen_string_literal: true
 
-require_relative "dead_end/internals"
+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)
+    file = PathnameFromMessage.new(e.message).call.name
+    raise e unless file
+
+    $stderr.sync = true
+
+    call(
+      source: file.read,
+      filename: file
+    )
+
+    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
+
+# Integration
+require_relative "dead_end/cli"
 require_relative "dead_end/auto"
+
+# Core logic
+require_relative "dead_end/code_search"
+require_relative "dead_end/code_frontier"
+require_relative "dead_end/explain_syntax"
+require_relative "dead_end/clean_document"
+
+# Helpers
+require_relative "dead_end/lex_all"
+require_relative "dead_end/code_line"
+require_relative "dead_end/code_block"
+require_relative "dead_end/block_expand"
+require_relative "dead_end/ripper_errors"
+require_relative "dead_end/insertion_sort"
+require_relative "dead_end/around_block_scan"
+require_relative "dead_end/pathname_from_message"
+require_relative "dead_end/display_invalid_blocks"
+require_relative "dead_end/parse_blocks_from_indent_line"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dead_end
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.2
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-19 00:00:00.000000000 Z
+date: 2021-11-12 00:00:00.000000000 Z
 dependencies: []
 description: When you get an "unexpected end" in your syntax this gem helps you find
   it
@@ -38,23 +38,25 @@ files:
 - lib/dead_end.rb
 - lib/dead_end/around_block_scan.rb
 - lib/dead_end/auto.rb
-- lib/dead_end/banner.rb
 - lib/dead_end/block_expand.rb
 - lib/dead_end/capture_code_context.rb
 - lib/dead_end/clean_document.rb
+- lib/dead_end/cli.rb
 - lib/dead_end/code_block.rb
 - lib/dead_end/code_frontier.rb
 - lib/dead_end/code_line.rb
 - lib/dead_end/code_search.rb
 - lib/dead_end/display_code_with_line_numbers.rb
 - lib/dead_end/display_invalid_blocks.rb
-- lib/dead_end/fyi.rb
-- lib/dead_end/internals.rb
+- lib/dead_end/explain_syntax.rb
+- lib/dead_end/insertion_sort.rb
+- lib/dead_end/left_right_lex_count.rb
 - 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
-- lib/dead_end/who_dis_syntax_error.rb
 homepage: https://github.com/zombocom/dead_end.git
 licenses:
 - MIT

data/lib/dead_end/banner.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module DeadEnd
-  class Banner
-    attr_reader :invalid_obj
-
-    def initialize(invalid_obj:)
-      @invalid_obj = invalid_obj
-    end
-
-    def call
-      case invalid_obj.error_symbol
-      when :missing_end
-        <<~EOM
-          DeadEnd: Missing `end` detected
-
-          This code has a missing `end`. Ensure that all
-          syntax keywords (`def`, `do`, etc.) have a matching `end`.
-        EOM
-      when :unmatched_syntax
-        case unmatched_symbol
-        when :end
-          <<~EOM
-            DeadEnd: Unmatched `end` detected
-
-            This code has an unmatched `end`. Ensure that all `end` lines
-            in your code have a matching syntax keyword  (`def`,  `do`, etc.)
-            and that you don't have any extra `end` lines.
-          EOM
-        when :|
-          <<~EOM
-            DeadEnd: Unmatched `|` character detected
-
-            Example:
-
-              `do |x` should be `do |x|`
-          EOM
-        when *WhoDisSyntaxError::CHARACTERS.keys
-          <<~EOM
-            DeadEnd: Unmatched `#{unmatched_symbol}` character detected
-
-            It appears a `#{missing_character}` might be missing.
-          EOM
-        else
-          "DeadEnd: Unmatched `#{unmatched_symbol}` detected"
-        end
-      end
-    end
-
-    private def unmatched_symbol
-      invalid_obj.unmatched_symbol
-    end
-
-    private def missing_character
-      WhoDisSyntaxError::CHARACTERS[unmatched_symbol]
-    end
-  end
-end

data/lib/dead_end/fyi.rb

@@ -1,8 +0,0 @@
-require_relative "../dead_end/internals"
-
-require_relative "auto"
-
-DeadEnd.send(:remove_const, :SEARCH_SOURCE_ON_ERROR_DEFAULT)
-DeadEnd::SEARCH_SOURCE_ON_ERROR_DEFAULT = false
-
-warn "DEPRECATED: calling `require 'dead_end/fyi'` is deprecated, `require 'dead_end'` instead"

data/lib/dead_end/internals.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-# This is the top level file, but is moved to `internals`
-# so the top level require can instead enable the "automatic" behavior
-
-require_relative "version"
-
-require "tmpdir"
-require "stringio"
-require "pathname"
-require "ripper"
-require "timeout"
-
-module DeadEnd
-  class Error < StandardError; end
-  SEARCH_SOURCE_ON_ERROR_DEFAULT = true
-  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 unless e.message.include?("end-of-input")
-
-    filename = e.message.split(":").first
-
-    $stderr.sync = true
-    warn "Run `$ dead_end #{filename}` for more options\n"
-
-    if search_source_on_error
-      call(
-        source: Pathname(filename).read,
-        filename: filename,
-        terminal: true
-      )
-    end
-
-    raise e
-  end
-
-  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
-
-    blocks = search.invalid_blocks
-    DisplayInvalidBlocks.new(
-      blocks: blocks,
-      filename: filename,
-      terminal: terminal,
-      code_lines: search.code_lines,
-      invalid_obj: invalid_type(source),
-      io: io
-    ).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
-
-  def self.invalid_type(source)
-    WhoDisSyntaxError.new(source).call
-  end
-end
-
-require_relative "code_line"
-require_relative "code_block"
-require_relative "code_search"
-require_relative "code_frontier"
-require_relative "clean_document"
-
-require_relative "lex_all"
-require_relative "block_expand"
-require_relative "around_block_scan"
-require_relative "who_dis_syntax_error"
-require_relative "display_invalid_blocks"
-require_relative "parse_blocks_from_indent_line"

data/lib/dead_end/who_dis_syntax_error.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module DeadEnd
-  # Determines what type of syntax error that is in the source
-  #
-  # Example:
-  #
-  #   puts WhoDisSyntaxError.new("def foo;").call.error_symbol
-  #   # => :missing_end
-  class WhoDisSyntaxError < Ripper
-    CHARACTERS = {"{": :"}", "}": :"{", "[": :"]", "]": :"[", "(": :")", ")": :"("}
-    class Null
-      def error_symbol
-        :missing_end
-      end
-
-      def unmatched_symbol
-        :end
-      end
-    end
-    attr_reader :error, :run_once
-
-    # Return options:
-    #   - :missing_end
-    #   - :unmatched_syntax
-    #   - :unknown
-    def error_symbol
-      call
-      @error_symbol
-    end
-
-    # Return options:
-    #   - :end
-    #   - :|
-    #   - :}
-    #   - :unknown
-    def unmatched_symbol
-      call
-      @unmatched_symbol
-    end
-
-    def call
-      @run_once ||= begin
-        parse
-        true
-      end
-      self
-    end
-
-    def on_parse_error(msg)
-      return if @error_symbol && @unmatched_symbol
-
-      @error = msg
-      @unmatched_symbol = :unknown
-
-      case @error
-      when /unexpected end-of-input/
-        @error_symbol = :missing_end
-      when /expecting end-of-input/
-        @unmatched_symbol = :end
-        @error_symbol = :unmatched_syntax
-      when /unexpected .* expecting ['`]?(?<unmatched_symbol>[^']*)/
-        if $1
-          character = $1.to_sym
-          @unmatched_symbol = CHARACTERS[character] || character
-          @unmatched_symbol = :end if @unmatched_symbol == :keyword_end
-        end
-        @error_symbol = :unmatched_syntax
-      when /unexpected '(?<unmatched_symbol>.*)'/
-        @unmatched_symbol = $1.to_sym
-        @unmatched_symbol = :end if @unmatched_symbol == :keyword_end
-        @error_symbol = :unmatched_syntax
-      when /unexpected `end'/, # Ruby 2.7 and 3.0
-           /unexpected end/, # Ruby 2.6
-           /unexpected keyword_end/i # Ruby 2.5
-
-        @error_symbol = :unmatched_syntax
-      else
-        @error_symbol = :unknown
-      end
-    end
-  end
-end