dead_end 1.1.7 → 3.1.1

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,29 @@ 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
+      @lex
     end
 
     def each
@@ -31,34 +42,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,70 @@
+# frozen_string_literal: true
+
+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, last_lex = nil)
+      @line = line
+      @type = type
+      @token = token
+      @state = state
+
+      set_kw_end(last_lex)
+    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"
+        # 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 fname?
+      state.allbits?(Ripper::EXPR_FNAME)
+    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
@@ -29,7 +29,7 @@ module DeadEnd
   class ParseBlocksFromIndentLine
     attr_reader :code_lines
 
-    def initialize(code_lines: )
+    def initialize(code_lines:)
       @code_lines = code_lines
     end
 
@@ -38,7 +38,7 @@ module DeadEnd
       scan = AroundBlockScan.new(code_lines: code_lines, block: CodeBlock.new(lines: target_line))
         .skip(:empty?)
         .skip(:hidden?)
-        .scan_while {|line| line.indent >= target_line.indent }
+        .scan_while { |line| line.indent >= target_line.indent }
 
       neighbors = scan.code_block.lines
 
@@ -53,4 +53,3 @@ module DeadEnd
     end
   end
 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

@@ -0,0 +1,36 @@
+# 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
+
+    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 = []
+        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.1.7"
+  VERSION = "3.1.1"
 end

data/lib/dead_end.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
-require_relative "dead_end/internals"
-require_relative "dead_end/auto"
+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: 1.1.7
+  version: 3.1.1
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-10 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
@@ -23,7 +23,7 @@ files:
 - ".github/workflows/check_changelog.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
+- ".standard.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -36,24 +36,29 @@ 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
 - 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/core_ext.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/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/trailing_slash_join.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
@@ -75,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Find syntax errors in your source in a snap

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.7.2
-before_install: gem install bundler -v 2.1.4

data/lib/dead_end/fyi.rb

@@ -1,7 +0,0 @@
-require_relative "../dead_end/internals"
-
-require_relative "auto.rb"
-
-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,30 +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

data/lib/dead_end/trailing_slash_join.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module DeadEnd
-  # Handles code that contains trailing slashes
-  # by turning multiple lines with trailing slash(es) into
-  # a single code line
-  #
-  #   expect(code_lines.join).to eq(<<~EOM)
-  #     it "trailing \
-  #        "slash" do
-  #     end
-  #   EOM
-  #
-  #   lines = TrailngSlashJoin(code_lines: code_lines).call
-  #   expect(lines.first.to_s).to eq(<<~EOM)
-  #     it "trailing \
-  #        "slash" do
-  #   EOM
-  #
-  class TrailingSlashJoin
-    def initialize(code_lines:)
-      @code_lines = code_lines
-      @code_lines_dup = code_lines.dup
-    end
-
-    def call
-      @trailing_lines = []
-      @code_lines.select(&:trailing_slash?).each do |trailing|
-        stop_next = false
-        lines = @code_lines[trailing.index..-1].take_while do |line|
-          next false if stop_next
-
-          if !line.trailing_slash?
-            stop_next = true
-          end
-
-          true
-        end
-
-        joined_line = CodeLine.new(line: lines.map(&:original_line).join, index: trailing.index)
-
-        @code_lines_dup[trailing.index] = joined_line
-
-        @trailing_lines << joined_line
-
-        lines.shift # Don't hide first trailing slash line
-        lines.each(&:mark_invisible)
-      end
-
-      return @code_lines_dup
-    end
-  end
-end

data/lib/dead_end/who_dis_syntax_error.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module DeadEnd
-  # Determines what type of syntax error is in the source
-  #
-  # Example:
-  #
-  #   puts WhoDisSyntaxError.new("def foo;").call.error_symbol
-  #   # => :missing_end
-  class WhoDisSyntaxError < Ripper
-    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>.*)'/
-        @unmatched_symbol = $1.to_sym if $1
-        @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