dead_end 1.2.0 → 3.0.0

data/lib/dead_end/left_right_lex_count.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Find mis-matched syntax based on lexical count
+  #
+  # Used for detecting missing pairs of elements
+  # each keyword needs an end, each '{' needs a '}'
+  # etc.
+  #
+  # Example:
+  #
+  #   left_right = LeftRightLexCount.new
+  #   left_right.count_kw
+  #   left_right.missing.first
+  #   # => "end"
+  #
+  #   left_right = LeftRightLexCount.new
+  #   source = "{ a: b, c: d" # Note missing '}'
+  #   LexAll.new(source: source).each do |lex|
+  #     left_right.count_lex(lex)
+  #   end
+  #   left_right.missing.first
+  #   # => "}"
+  class LeftRightLexCount
+    def initialize
+      @kw_count = 0
+      @end_count = 0
+
+      @count_for_char = {
+        "{" => 0,
+        "}" => 0,
+        "[" => 0,
+        "]" => 0,
+        "(" => 0,
+        ")" => 0,
+        "|" => 0
+      }
+    end
+
+    def count_kw
+      @kw_count += 1
+    end
+
+    def count_end
+      @end_count += 1
+    end
+
+    # Count source code characters
+    #
+    # Example:
+    #
+    #   left_right = LeftRightLexCount.new
+    #   left_right.count_lex(LexValue.new(1, :on_lbrace, "{", Ripper::EXPR_BEG))
+    #   left_right.count_for_char("{")
+    #   # => 1
+    #   left_right.count_for_char("}")
+    #   # => 0
+    def count_lex(lex)
+      case lex.type
+      when :on_tstring_content
+        # ^^^
+        # Means it's a string or a symbol `"{"` rather than being
+        # part of a data structure (like a hash) `{ a: b }`
+      when :on_embexpr_beg
+        # ^^^
+        # Embedded string expressions like `"#{foo} <-embed"`
+        # are parsed with chars:
+        #
+        # `#{` as :on_embexpr_beg
+        #  `}` as :on_embexpr_end
+        #
+        # We cannot ignore both :on_emb_expr_beg and :on_embexpr_end
+        # because sometimes the lexer thinks something is an embed
+        # string end, when it is not like `lol = }` (no clue why).
+        #
+        # When we see `#{` count it as a `{` or we will
+        # have a mis-match count.
+        #
+        case lex.token
+        when "\#{"
+          @count_for_char["{"] += 1
+        end
+      else
+        @end_count += 1 if lex.is_end?
+        @kw_count += 1 if lex.is_kw?
+        @count_for_char[lex.token] += 1 if @count_for_char.key?(lex.token)
+      end
+    end
+
+    def count_for_char(char)
+      @count_for_char[char]
+    end
+
+    # Returns an array of missing syntax characters
+    # or `"end"` or `"keyword"`
+    #
+    #   left_right.missing
+    #   # => ["}"]
+    def missing
+      out = missing_pairs
+      out << missing_pipe
+      out << missing_keyword_end
+      out.compact!
+      out
+    end
+
+    PAIRS = {
+      "{" => "}",
+      "[" => "]",
+      "(" => ")"
+    }.freeze
+
+    # Opening characters like `{` need closing characters # like `}`.
+    #
+    # When a mis-match count is detected, suggest the
+    # missing member.
+    #
+    # For example if there are 3 `}` and only two `{`
+    # return `"{"`
+    private def missing_pairs
+      PAIRS.map do |(left, right)|
+        case @count_for_char[left] <=> @count_for_char[right]
+        when 1
+          right
+        when 0
+          nil
+        when -1
+          left
+        end
+      end
+    end
+
+    # Keywords need ends and ends need keywords
+    #
+    # If we have more keywords, there's a missing `end`
+    # if we have more `end`-s, there's a missing keyword
+    private def missing_keyword_end
+      case @kw_count <=> @end_count
+      when 1
+        "end"
+      when 0
+        nil
+      when -1
+        "keyword"
+      end
+    end
+
+    # Pipes come in pairs.
+    # If there's an odd number of pipes then we
+    # are missing one
+    private def missing_pipe
+      if @count_for_char["|"].odd?
+        "|"
+      end
+    end
+  end
+end

data/lib/dead_end/lex_all.rb

@@ -15,7 +15,7 @@ module DeadEnd
       last_lineno = source_lines.count
 
       until lineno >= last_lineno
-        lines = source_lines[lineno..]
+        lines = source_lines[lineno..-1]
 
         @lex.concat(Ripper.lex(lines.join, "-", lineno + 1))
         lineno = @lex.last.first.first + 1
@@ -24,6 +24,10 @@ module DeadEnd
       @lex.map! { |(line, _), type, token, state| LexValue.new(line, type, token, state) }
     end
 
+    def to_a
+      @lex
+    end
+
     def each
       return @lex.each unless block_given?
       @lex.each do |x|
@@ -31,34 +35,14 @@ module DeadEnd
       end
     end
 
-    def last
-      @lex.last
+    def [](index)
+      @lex[index]
     end
 
-    # Value object for accessing lex values
-    #
-    # This lex:
-    #
-    #   [1, 0], :on_ident, "describe", CMDARG
-    #
-    # Would translate into:
-    #
-    #  lex.line # => 1
-    #  lex.type # => :on_indent
-    #  lex.token # => "describe"
-    class LexValue
-      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
+    def last
+      @lex.last
     end
   end
 end
+
+require_relative "lex_value"

data/lib/dead_end/lex_value.rb

@@ -0,0 +1,62 @@
+module DeadEnd
+  # Value object for accessing lex values
+  #
+  # This lex:
+  #
+  #   [1, 0], :on_ident, "describe", CMDARG
+  #
+  # Would translate into:
+  #
+  #  lex.line # => 1
+  #  lex.type # => :on_indent
+  #  lex.token # => "describe"
+  class LexValue
+    attr_reader :line, :type, :token, :state
+
+    def initialize(line, type, token, state)
+      @line = line
+      @type = type
+      @token = token
+      @state = state
+
+      set_kw_end
+    end
+
+    private def set_kw_end
+      @is_end = false
+      @is_kw = false
+      return if type != :on_kw
+
+      case token
+      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
+        @is_kw = true unless expr_label?
+      when "def", "case", "for", "begin", "class", "module", "do"
+        @is_kw = true
+      when "end"
+        @is_end = true
+      end
+    end
+
+    def ignore_newline?
+      type == :on_ignored_nl
+    end
+
+    def is_end?
+      @is_end
+    end
+
+    def is_kw?
+      @is_kw
+    end
+
+    def expr_beg?
+      state.anybits?(Ripper::EXPR_BEG)
+    end
+
+    def expr_label?
+      state.allbits?(Ripper::EXPR_LABEL)
+    end
+  end
+end

data/lib/dead_end/parse_blocks_from_indent_line.rb

@@ -4,7 +4,7 @@ module DeadEnd
   # This class is responsible for generating initial code blocks
   # that will then later be expanded.
   #
-  # The biggest concern when guessing about code blocks, is accidentally
+  # The biggest concern when guessing code blocks, is accidentally
   # grabbing one that contains only an "end". In this example:
   #
   #   def dog

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 = "1.2.0"
+  VERSION = "3.0.0"
 end

data/lib/dead_end.rb

@@ -1,4 +1,148 @@
 # 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)
+    filename = e.message.split(":").first
+    $stderr.sync = true
+
+    call(
+      source: Pathname(filename).read,
+      filename: filename
+    )
+
+    raise e
+  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/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"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dead_end
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2021-11-03 00:00:00.000000000 Z
 dependencies: []
 description: When you get an "unexpected end" in your syntax this gem helps you find
   it
@@ -40,20 +40,21 @@ files:
 - lib/dead_end/auto.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/heredoc_block_parse.rb
-- lib/dead_end/internals.rb
+- lib/dead_end/explain_syntax.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/trailing_slash_join.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/fyi.rb

@@ -1,6 +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

data/lib/dead_end/heredoc_block_parse.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module DeadEnd
-  # Takes in a source, and returns blocks containing each heredoc
-  class HeredocBlockParse
-    private
-
-    attr_reader :code_lines, :lex
-
-    public
-
-    def initialize(source:, code_lines:)
-      @code_lines = code_lines
-      @lex = LexAll.new(source: source)
-    end
-
-    def call
-      blocks = []
-      beginning = []
-      @lex.each do |lex|
-        case lex.type
-        when :on_heredoc_beg
-          beginning << lex.line
-        when :on_heredoc_end
-          start_index = beginning.pop - 1
-          end_index = lex.line - 1
-          blocks << CodeBlock.new(lines: code_lines[start_index..end_index])
-        end
-      end
-
-      blocks
-    end
-  end
-end