dead_end 1.2.0 → 3.0.0

data/lib/dead_end/internals.rb

@@ -1,158 +0,0 @@
-# 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 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
-
-    warn ""
-    warn ""
-    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_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/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..].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
-
-      @code_lines_dup
-    end
-  end
-end

data/lib/dead_end/who_dis_syntax_error.rb

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