dead_end 1.0.0

data/lib/dead_end/display_code_with_line_numbers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Outputs code with highlighted lines
+  #
+  # Whatever is passed to this class will be rendered
+  # even if it is "marked invisible" any filtering of
+  # output should be done before calling this class.
+  #
+  #
+  #   DisplayCodeWithLineNumbers.new(
+  #     lines: lines,
+  #     highlight_lines: [lines[2], lines[3]]
+  #   ).call
+  #   # =>
+  #       1
+  #       2  def cat
+  #     ❯ 3    Dir.chdir
+  #     ❯ 4    end
+  #       5  end
+  #       6
+  class DisplayCodeWithLineNumbers
+    TERMINAL_HIGHLIGHT = "\e[1;3m" # Bold, italics
+    TERMINAL_END = "\e[0m"
+
+    def initialize(lines: , highlight_lines: [], terminal: false)
+      @lines = Array(lines).sort
+      @terminal = terminal
+      @highlight_line_hash = Array(highlight_lines).each_with_object({}) {|line, h| h[line] = true  }
+      @digit_count = @lines.last&.line_number.to_s.length
+    end
+
+    def call
+      @lines.map do |line|
+        format_line(line)
+      end.join
+    end
+
+    private def format_line(code_line)
+      # Handle trailing slash lines
+      code_line.original.lines.map.with_index do |contents, i|
+        format(
+          empty: code_line.empty?,
+          number: (code_line.number + i).to_s,
+          contents: contents,
+          highlight: @highlight_line_hash[code_line]
+        )
+      end.join
+    end
+
+    private def format(contents: , number: , highlight: false, empty:)
+      string = String.new("")
+      if highlight
+        string << "❯ "
+      else
+        string << "  "
+      end
+
+      string << number.rjust(@digit_count).to_s
+      if empty
+        string << contents
+      else
+        string << "  "
+        string << TERMINAL_HIGHLIGHT if @terminal && highlight
+        string << contents
+        string << TERMINAL_END if @terminal
+      end
+      string
+    end
+  end
+end

data/lib/dead_end/display_invalid_blocks.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "capture_code_context"
+require_relative "display_code_with_line_numbers"
+
+module DeadEnd
+  # Used for formatting invalid blocks
+  class DisplayInvalidBlocks
+    attr_reader :filename
+
+    def initialize(code_lines: ,blocks:, io: $stderr, filename: nil, terminal: false, invalid_obj: WhoDisSyntaxError::Null.new)
+      @terminal = terminal
+      @filename = filename
+      @io = io
+
+      @blocks = Array(blocks)
+
+      @invalid_lines = @blocks.map(&:lines).flatten
+      @code_lines = code_lines
+
+      @invalid_obj = invalid_obj
+    end
+
+    def call
+      if @blocks.any? { |b| !b.hidden? }
+        found_invalid_blocks
+      else
+        @io.puts "Syntax OK"
+      end
+      self
+    end
+
+    private def no_invalid_blocks
+      @io.puts <<~EOM
+      EOM
+    end
+
+    private def found_invalid_blocks
+      @io.puts
+      @io.puts banner
+      @io.puts
+      @io.puts("file: #{filename}") if filename
+      @io.puts <<~EOM
+        simplified:
+
+        #{indent(code_block)}
+      EOM
+    end
+
+    def banner
+      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 @invalid_obj.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 :"}"
+          <<~EOM
+            DeadEnd: Unmatched `}` character detected
+
+            This code has an unmatched `}`. Ensure that opening curl braces are
+            closed: `{ }`.
+          EOM
+        else
+          "DeadEnd: Unmatched #{@invalid_obj.unmatched_symbol}` detected"
+        end
+      end
+
+    end
+
+    def indent(string, with: "    ")
+      string.each_line.map {|l| with  + l }.join
+    end
+
+    def code_block
+      string = String.new("")
+      string << code_with_context
+      string
+    end
+
+    def code_with_context
+      lines = CaptureCodeContext.new(
+        blocks: @blocks,
+        code_lines: @code_lines
+      ).call
+
+      DisplayCodeWithLineNumbers.new(
+        lines: lines,
+        terminal: @terminal,
+        highlight_lines: @invalid_lines,
+      ).call
+    end
+
+    def code_with_lines
+      DisplayCodeWithLineNumbers.new(
+        lines: @code_lines.select(&:visible?),
+        terminal: @terminal,
+        highlight_lines: @invalid_lines,
+      ).call
+    end
+  end
+end

data/lib/dead_end/fyi.rb

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

@@ -0,0 +1,30 @@
+# 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/internals.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+#
+# This is the top level file, but is moved to `internals`
+# so the top level file 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", 5).to_i
+
+  def self.handle_error(e, search_source_on_error: SEARCH_SOURCE_ON_ERROR_DEFAULT)
+    raise e if !e.message.include?("end-of-input")
+
+    filename = e.message.split(":").first
+
+    $stderr.sync = true
+    $stderr.puts "Run `$ dead_end #{filename}` for more options\n"
+
+    if search_source_on_error
+      self.call(
+        source: Pathname(filename).read,
+        filename: filename,
+        terminal: true,
+      )
+    end
+
+    $stderr.puts ""
+    $stderr.puts ""
+    raise e
+  end
+
+  def self.call(source: , filename: , terminal: false, record_dir: nil, timeout: TIMEOUT_DEFAULT)
+    search = nil
+    Timeout.timeout(timeout) do
+      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: $stderr
+    ).call
+  rescue Timeout::Error
+    $stderr.puts "Search timed out DEAD_END_TIMEOUT=#{timeout}, run with DEBUG=1 for more info"
+  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?
+      return true
+    else
+      return 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_frontier"
+require_relative "display_invalid_blocks"
+require_relative "around_block_scan"
+require_relative "block_expand"
+require_relative "parse_blocks_from_indent_line"
+
+require_relative "code_search"
+require_relative "who_dis_syntax_error"
+require_relative "heredoc_block_parse"
+require_relative "lex_all"
+require_relative "trailing_slash_join"

data/lib/dead_end/lex_all.rb

@@ -0,0 +1,58 @@
+module DeadEnd
+  # Ripper.lex is not guaranteed to lex the entire source document
+  #
+  # lex = LexAll.new(source: source)
+  # lex.each do |value|
+  #   puts value.line
+  # end
+  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
+
+      until lineno >= last_lineno
+        lines = source_lines[lineno..-1]
+
+        @lex.concat(Ripper.lex(lines.join, '-', lineno + 1))
+        lineno = @lex.last&.first&.first + 1
+      end
+
+      @lex.map! {|(line, _), type, token| LexValue.new(line, _, type, token) }
+    end
+
+    def each
+      return @lex.each unless block_given?
+      @lex.each do |x|
+        yield x
+      end
+    end
+
+    def last
+      @lex.last
+    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
+      def initialize(line, _, type, token)
+        @line = line
+        @type = type
+        @token = token
+      end
+    end
+  end
+end