syntax_search 0.2.0 → 0.2.1

data/lib/syntax_search/code_search.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # Searches code for a syntax error
-  #
-  # The bulk of the heavy lifting is done in:
-  #
-  #  - CodeFrontier (Holds information for generating blocks and determining if we can stop searching)
-  #  - ParseBlocksFromLine (Creates blocks into the frontier)
-  #  - BlockExpand (Expands existing blocks to search more code
-  #
-  # ## Syntax error detection
-  #
-  # When the frontier holds the syntax error, we can stop searching
-  #
-  #   search = CodeSearch.new(<<~EOM)
-  #     def dog
-  #       def lol
-  #     end
-  #   EOM
-  #
-  #   search.call
-  #
-  #   search.invalid_blocks.map(&:to_s) # =>
-  #   # => ["def lol\n"]
-  #
-  class CodeSearch
-    private; attr_reader :frontier; public
-    public; attr_reader :invalid_blocks, :record_dir, :code_lines
-
-    def initialize(source, record_dir: ENV["SYNTAX_SEARCH_RECORD_DIR"] || ENV["DEBUG"] ? "tmp" : nil)
-      @source = source
-      if record_dir
-        @time = Time.now.strftime('%Y-%m-%d-%H-%M-%s-%N')
-        @record_dir = Pathname(record_dir).join(@time).tap {|p| p.mkpath }
-        @write_count = 0
-      end
-      @code_lines = source.lines.map.with_index do |line, i|
-        CodeLine.new(line: line, index: i)
-      end
-      @frontier = CodeFrontier.new(code_lines: @code_lines)
-      @invalid_blocks = []
-      @name_tick = Hash.new {|hash, k| hash[k] = 0 }
-      @tick = 0
-      @block_expand = BlockExpand.new(code_lines: code_lines)
-      @parse_blocks_from_indent_line = ParseBlocksFromIndentLine.new(code_lines: @code_lines)
-    end
-
-    # Used for debugging
-    def record(block:, name: "record")
-      return if !@record_dir
-      @name_tick[name] += 1
-      filename = "#{@write_count += 1}-#{name}-#{@name_tick[name]}.txt"
-      if ENV["DEBUG"]
-        puts "\n\n==== #{filename} ===="
-        puts "\n```#{block.starts_at}:#{block.ends_at}"
-        puts "#{block.to_s}"
-        puts "```"
-        puts "  block indent:     #{block.current_indent}"
-      end
-      @record_dir.join(filename).open(mode: "a") do |f|
-        display = DisplayInvalidBlocks.new(
-          blocks: block,
-          terminal: false,
-          code_lines: @code_lines,
-        )
-        f.write(display.indent display.code_with_lines)
-      end
-    end
-
-    def push(block, name: )
-      record(block: block, name: name)
-
-      if block.valid?
-        block.lines.each(&:mark_invisible)
-        frontier << block
-      else
-        frontier << block
-      end
-    end
-
-    # Removes the block without putting it back in the frontier
-    def sweep(block:, name: )
-      record(block: block, name: name)
-
-      block.lines.each(&:mark_invisible)
-      frontier.register_indent_block(block)
-    end
-
-    # Parses the most indented lines into blocks that are marked
-    # and added to the frontier
-    def add_invalid_blocks
-      max_indent = frontier.next_indent_line&.indent
-
-      while (line = frontier.next_indent_line) && (line.indent == max_indent)
-
-        @parse_blocks_from_indent_line.each_neighbor_block(frontier.next_indent_line) do |block|
-          record(block: block, name: "add")
-
-          block.mark_invisible if block.valid?
-          push(block, name: "add")
-        end
-      end
-    end
-
-    # Given an already existing block in the frontier, expand it to see
-    # if it contains our invalid syntax
-    def expand_invalid_block
-      block = frontier.pop
-      return unless block
-
-      record(block: block, name: "pop")
-
-      # block = block.expand_until_next_boundry
-      block = @block_expand.call(block)
-      push(block, name: "expand")
-    end
-
-    def sweep_heredocs
-      HeredocBlockParse.new(
-        source: @source,
-        code_lines: @code_lines
-      ).call.each do |block|
-        push(block, name: "heredoc")
-      end
-    end
-
-    def sweep_comments
-      lines = @code_lines.select(&:is_comment?)
-      return if lines.empty?
-      block = CodeBlock.new(lines: lines)
-      sweep(block: block, name: "comments")
-    end
-
-    # Main search loop
-    def call
-      sweep_heredocs
-      sweep_comments
-      until frontier.holds_all_syntax_errors?
-        @tick += 1
-
-        if frontier.expand?
-          expand_invalid_block
-        else
-          add_invalid_blocks
-        end
-      end
-
-      @invalid_blocks.concat(frontier.detect_invalid_blocks )
-      @invalid_blocks.sort_by! {|block| block.starts_at }
-      self
-    end
-  end
-end

data/lib/syntax_search/display_code_with_line_numbers.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # 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 = lines.sort
-      @terminal = terminal
-      @highlight_line_hash = 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|
-        string = String.new("")
-        if @highlight_line_hash[line]
-          string << "❯ "
-        else
-          string << "  "
-        end
-
-        number = line.line_number.to_s.rjust(@digit_count)
-        string << number.to_s
-        if line.empty?
-          string << line.original_line
-        else
-          string << "  "
-          string << TERMINAL_HIGHLIGHT if @terminal && @highlight_line_hash[line] # Bold, italics
-          string << line.original_line
-          string << TERMINAL_END if @terminal
-        end
-        string
-      end.join
-    end
-  end
-end

data/lib/syntax_search/display_invalid_blocks.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "capture_code_context"
-require_relative "display_code_with_line_numbers"
-
-module SyntaxErrorSearch
-  # Used for formatting invalid blocks
-  class DisplayInvalidBlocks
-    attr_reader :filename
-
-    def initialize(code_lines: ,blocks:, io: $stderr, filename: nil, terminal: false, invalid_type: :unmatched_end)
-      @terminal = terminal
-      @filename = filename
-      @io = io
-
-      @blocks = Array(blocks)
-
-      @invalid_lines = @blocks.map(&:lines).flatten
-      @code_lines = code_lines
-
-      @invalid_type = invalid_type
-    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
-      case @invalid_type
-      when :missing_end
-        @io.puts <<~EOM
-
-          SyntaxSearch: Missing `end` detected
-
-          This code has a missing `end`. Ensure that all
-          syntax keywords (`def`, `do`, etc.) have a matching `end`.
-
-        EOM
-      when :unmatched_end
-        @io.puts <<~EOM
-
-          SyntaxSearch: 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
-      end
-
-      @io.puts("file: #{filename}") if filename
-      @io.puts <<~EOM
-        simplified:
-
-        #{indent(code_block)}
-      EOM
-    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/syntax_search/fyi.rb

@@ -1,7 +0,0 @@
-require_relative "../syntax_search"
-
-require_relative "auto.rb"
-
-SyntaxErrorSearch.send(:remove_const, :SEARCH_SOURCE_ON_ERROR_DEFAULT)
-SyntaxErrorSearch::SEARCH_SOURCE_ON_ERROR_DEFAULT = false
-

data/lib/syntax_search/heredoc_block_parse.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # 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/syntax_search/lex_all.rb

@@ -1,58 +0,0 @@
-module SyntaxErrorSearch
-  # 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

data/lib/syntax_search/parse_blocks_from_indent_line.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # 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
-  # grabbing one that contains only an "end". In this example:
-  #
-  #   def dog
-  #     begonn # mispelled `begin`
-  #     puts "bark"
-  #     end
-  #   end
-  #
-  # The following lines would be matched (from bottom to top):
-  #
-  #   1) end
-  #
-  #   2) puts "bark"
-  #      end
-  #
-  #   3) begonn
-  #      puts "bark"
-  #      end
-  #
-  # At this point it has no where else to expand, and it will yield this inner
-  # code as a block
-  class ParseBlocksFromIndentLine
-    attr_reader :code_lines
-
-    def initialize(code_lines: )
-      @code_lines = code_lines
-    end
-
-    # Builds blocks from bottom up
-    def each_neighbor_block(target_line)
-      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 }
-
-      neighbors = @code_lines[scan.before_index..scan.after_index]
-
-      until neighbors.empty?
-        lines = [neighbors.pop]
-        while (block = CodeBlock.new(lines: lines)) && block.invalid? && neighbors.any?
-          lines.prepend neighbors.pop
-        end
-
-        yield block if block
-      end
-    end
-  end
-end
-