syntax_search 0.2.0 → 0.2.1

data/lib/syntax_search/block_expand.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-module SyntaxErrorSearch
-  # This class is responsible for taking a code block that exists
-  # at a far indentaion and then iteratively increasing the block
-  # so that it captures everything within the same indentation block.
-  #
-  #   def dog
-  #     puts "bow"
-  #     puts "wow"
-  #   end
-  #
-  # block = BlockExpand.new(code_lines: code_lines)
-  #   .call(CodeBlock.new(lines: code_lines[1]))
-  #
-  # puts block.to_s
-  # # => puts "bow"
-  #      puts "wow"
-  #
-  #
-  # Once a code block has captured everything at a given indentation level
-  # then it will expand to capture surrounding indentation.
-  #
-  # block = BlockExpand.new(code_lines: code_lines)
-  #   .call(block)
-  #
-  # block.to_s
-  # # => def dog
-  #        puts "bow"
-  #        puts "wow"
-  #      end
-  #
-  class BlockExpand
-    def initialize(code_lines: )
-      @code_lines = code_lines
-    end
-
-    def call(block)
-      if (next_block = expand_neighbors(block, grab_empty: true))
-        return next_block
-      end
-
-      expand_indent(block)
-    end
-
-    def expand_indent(block)
-      block = AroundBlockScan.new(code_lines: @code_lines, block: block)
-        .skip(:hidden?)
-        .stop_after_kw
-        .scan_adjacent_indent
-        .code_block
-    end
-
-    def expand_neighbors(block, grab_empty: true)
-      scan = AroundBlockScan.new(code_lines: @code_lines, block: block)
-        .skip(:hidden?)
-        .stop_after_kw
-        .scan_neighbors
-
-      # Slurp up empties
-      if grab_empty
-        scan = AroundBlockScan.new(code_lines: @code_lines, block: scan.code_block)
-          .scan_while {|line| line.empty? || line.hidden? }
-      end
-
-      new_block = scan.code_block
-
-      if block.lines == new_block.lines
-        return nil
-      else
-        return new_block
-      end
-    end
-  end
-end

data/lib/syntax_search/capture_code_context.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-
-  # Given a block, this method will capture surrounding
-  # code to give the user more context for the location of
-  # the problem.
-  #
-  # Return is an array of CodeLines to be rendered.
-  #
-  # Surrounding code is captured regardless of visible state
-  #
-  #   puts block.to_s # => "def bark"
-  #
-  #   context = CaptureCodeContext.new(
-  #     blocks: block,
-  #     code_lines: code_lines
-  #   )
-  #
-  #   puts context.call.join
-  #   # =>
-  #     class Dog
-  #       def bark
-  #     end
-  #
-  class CaptureCodeContext
-    attr_reader :code_lines
-
-    def initialize(blocks: , code_lines:)
-      @blocks = Array(blocks)
-      @code_lines = code_lines
-      @visible_lines = @blocks.map(&:visible_lines).flatten
-      @lines_to_output = @visible_lines.dup
-    end
-
-    def call
-      @blocks.each do |block|
-        around_lines = AroundBlockScan.new(code_lines: @code_lines, block: block)
-          .start_at_next_line
-          .capture_neighbor_context
-
-        around_lines -= block.lines
-
-        @lines_to_output.concat(around_lines)
-
-        AroundBlockScan.new(
-          block: block,
-          code_lines: @code_lines,
-        ).on_falling_indent do |line|
-          @lines_to_output << line
-        end
-      end
-
-      @lines_to_output.select!(&:not_empty?)
-      @lines_to_output.select!(&:not_comment?)
-      @lines_to_output.uniq!
-      @lines_to_output.sort!
-
-      return @lines_to_output
-    end
-  end
-end

data/lib/syntax_search/code_block.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # Multiple lines form a singular CodeBlock
-  #
-  # Source code is made of multiple CodeBlocks.
-  #
-  # Example:
-  #
-  #   code_block.to_s # =>
-  #     #   def foo
-  #     #     puts "foo"
-  #     #   end
-  #
-  #   code_block.valid? # => true
-  #   code_block.in_valid? # => false
-  #
-  #
-  class CodeBlock
-    attr_reader :lines
-
-    def initialize(lines: [])
-      @lines = Array(lines)
-    end
-
-    def visible_lines
-      @lines.select(&:visible?).select(&:not_empty?)
-    end
-
-    def mark_invisible
-      @lines.map(&:mark_invisible)
-    end
-
-    def is_end?
-      to_s.strip == "end"
-    end
-
-    def hidden?
-      @lines.all?(&:hidden?)
-    end
-
-    def starts_at
-      @starts_at ||= @lines.first&.line_number
-    end
-
-    def ends_at
-      @ends_at ||= @lines.last&.line_number
-    end
-
-    # This is used for frontier ordering, we are searching from
-    # the largest indentation to the smallest. This allows us to
-    # populate an array with multiple code blocks then call `sort!`
-    # on it without having to specify the sorting criteria
-    def <=>(other)
-      out = self.current_indent <=> other.current_indent
-      return out if out != 0
-
-      # Stable sort
-      self.starts_at <=> other.starts_at
-    end
-
-    def current_indent
-      @current_indent ||= lines.select(&:not_empty?).map(&:indent).min || 0
-    end
-
-    def invalid?
-      !valid?
-    end
-
-    def valid?
-      SyntaxErrorSearch.valid?(self.to_s)
-    end
-
-    def to_s
-      @lines.join
-    end
-  end
-end

data/lib/syntax_search/code_frontier.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # The main function of the frontier is to hold the edges of our search and to
-  # evaluate when we can stop searching.
-  #
-  # ## Knowing where we've been
-  #
-  # Once a code block is generated it is added onto the frontier where it will be
-  # sorted and then the frontier can be filtered. Large blocks that totally contain a
-  # smaller block will cause the smaller block to be evicted.
-  #
-  #   CodeFrontier#<<
-  #   CodeFrontier#pop
-  #
-  # ## Knowing where we can go
-  #
-  # Internally it keeps track of an "indent hash" which is exposed via `next_indent_line`
-  # when called this will return a line of code with the most indentation.
-  #
-  # This line of code can be used to build a CodeBlock via and then when that code block
-  # is added back to the frontier, then the lines in the code block are removed from the
-  # indent hash so we don't double-create the same block.
-  #
-  #   CodeFrontier#next_indent_line
-  #   CodeFrontier#register_indent_block
-  #
-  # ## Knowing when to stop
-  #
-  # The frontier holds the syntax error when removing all code blocks from the original
-  # source document allows it to be parsed as syntatically valid:
-  #
-  #   CodeFrontier#holds_all_syntax_errors?
-  #
-  # ## Filtering false positives
-  #
-  # Once the search is completed, the frontier will have many blocks that do not contain
-  # the syntax error. To filter to the smallest subset that does call:
-  #
-  #   CodeFrontier#detect_invalid_blocks
-  class CodeFrontier
-    def initialize(code_lines: )
-      @code_lines = code_lines
-      @frontier = []
-      @indent_hash = {}
-      code_lines.each do |line|
-        next if line.empty?
-
-        @indent_hash[line.indent] ||= []
-        @indent_hash[line.indent] << line
-      end
-    end
-
-    def count
-      @frontier.count
-    end
-
-    # Returns true if the document is valid with all lines
-    # removed. By default it checks all blocks in present in
-    # the frontier array, but can be used for arbitrary arrays
-    # of codeblocks as well
-    def holds_all_syntax_errors?(block_array = @frontier)
-      without_lines = block_array.map do |block|
-        block.lines
-      end
-
-      SyntaxErrorSearch.valid_without?(
-        without_lines: without_lines,
-        code_lines: @code_lines
-      )
-    end
-
-    # Returns a code block with the largest indentation possible
-    def pop
-      return @frontier.pop
-    end
-
-    def indent_hash_indent
-      @indent_hash.keys.sort.last
-    end
-
-    def next_indent_line
-      indent = @indent_hash.keys.sort.last
-      @indent_hash[indent]&.first
-    end
-
-    def expand?
-      return false if @frontier.empty?
-      return true if @indent_hash.empty?
-
-      frontier_indent = @frontier.last.current_indent
-      hash_indent = @indent_hash.keys.sort.last
-
-      if ENV["DEBUG"]
-        puts "```"
-        puts @frontier.last.to_s
-        puts "```"
-        puts "  @frontier indent: #{frontier_indent}"
-        puts "  @hash indent:     #{hash_indent}"
-      end
-
-      frontier_indent >= hash_indent
-    end
-
-    def register_indent_block(block)
-      block.lines.each do |line|
-        @indent_hash[line.indent]&.delete(line)
-      end
-      @indent_hash.select! {|k, v| !v.empty?}
-      self
-    end
-
-    # Add a block to the frontier
-    #
-    # This method ensures the frontier always remains sorted (in indentation order)
-    # and that each code block's lines are removed from the indentation hash so we
-    # don't re-evaluate the same line multiple times.
-    def <<(block)
-      register_indent_block(block)
-
-      # Make sure we don't double expand, if a code block fully engulfs another code block, keep the bigger one
-      @frontier.reject! {|b|
-        b.starts_at >= block.starts_at && b.ends_at <= block.ends_at
-      }
-      @frontier << block
-      @frontier.sort!
-
-      self
-    end
-
-    # Example:
-    #
-    #   combination([:a, :b, :c, :d])
-    #   # => [[:a], [:b], [:c], [:d], [:a, :b], [:a, :c], [:a, :d], [:b, :c], [:b, :d], [:c, :d], [:a, :b, :c], [:a, :b, :d], [:a, :c, :d], [:b, :c, :d], [:a, :b, :c, :d]]
-    def self.combination(array)
-      guesses = []
-      1.upto(array.length).each do |size|
-        guesses.concat(array.combination(size).to_a)
-      end
-      guesses
-    end
-
-    # Given that we know our syntax error exists somewhere in our frontier, we want to find
-    # the smallest possible set of blocks that contain all the syntax errors
-    def detect_invalid_blocks
-      self.class.combination(@frontier).detect do |block_array|
-        holds_all_syntax_errors?(block_array)
-      end || []
-    end
-  end
-end

data/lib/syntax_search/code_line.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxErrorSearch
-  # Represents a single line of code of a given source file
-  #
-  # This object contains metadata about the line such as
-  # amount of indentation. An if it is empty or not.
-  #
-  # While a given search for syntax errors is being performed
-  # state about the search can be stored in individual lines such
-  # as :valid or :invalid.
-  #
-  # Visibility of lines can be toggled on and off.
-  #
-  # Example:
-  #
-  #   line = CodeLine.new(line: "def foo\n", index: 0)
-  #   line.line_number => 1
-  #   line.empty? # => false
-  #   line.visible? # => true
-  #   line.mark_invisible
-  #   line.visible? # => false
-  #
-  # A CodeBlock is made of multiple CodeLines
-  #
-  # Marking a line as invisible indicates that it should not be used
-  # for syntax checks. It's essentially the same as commenting it out
-  #
-  # Marking a line as invisible also lets the overall program know
-  # that it should not check that area for syntax errors.
-  class CodeLine
-    attr_reader :line, :index, :indent, :original_line
-
-    def initialize(line: , index:)
-      @original_line = line.freeze
-      @line = @original_line
-      @empty = line.strip.empty?
-      @index = index
-      @indent = SpaceCount.indent(line)
-      @status = nil # valid, invalid, unknown
-      @invalid = false
-
-      @kw_count = 0
-      @end_count = 0
-      @lex = LexAll.new(source: line)
-      @lex.each do |lex|
-        next unless lex.type == :on_kw
-
-        case lex.token
-        when 'def', 'case', 'for', 'begin', 'class', 'module', 'if', 'unless', 'while', 'until' , 'do'
-          @kw_count += 1
-        when 'end'
-          @end_count += 1
-        end
-      end
-
-      @is_comment = true if @lex.detect {|lex| lex.type != :on_sp}&.type == :on_comment
-
-      @is_kw = (@kw_count - @end_count) > 0
-      @is_end = (@end_count - @kw_count) > 0
-    end
-
-    def <=>(b)
-      self.index <=> b.index
-    end
-
-    def is_comment?
-      @is_comment
-    end
-
-    def not_comment?
-      !is_comment?
-    end
-
-    def is_kw?
-      @is_kw
-    end
-
-    def is_end?
-      @is_end
-    end
-
-    def mark_invalid
-      @invalid = true
-      self
-    end
-
-    def marked_invalid?
-      @invalid
-    end
-
-    def mark_invisible
-      @line = ""
-      self
-    end
-
-    def mark_visible
-      @line = @original_line
-      self
-    end
-
-    def visible?
-      !line.empty?
-    end
-
-    def hidden?
-      !visible?
-    end
-
-    def line_number
-      index + 1
-    end
-
-    alias :number :line_number
-
-    def not_empty?
-      !empty?
-    end
-
-    def empty?
-      @empty
-    end
-
-    def to_s
-      self.line
-    end
-  end
-end