syntax_search 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9efb5d44fe2c979f66237173d1bf7b215a1bcc8003b4a96cb595eabbcac606c6
-  data.tar.gz: 5757f68cdf7dace8980bb31b49a756b858fba8f7260156640621832374b4e635
+  metadata.gz: cb2c76d5b7441b5c04e92205407605d6f71be326bfbf240b11763156fc00e188
+  data.tar.gz: 728230f8d8694e221149a671d0c44f44d82829407cf5a82b498523015d9df33f
 SHA512:
-  metadata.gz: b9fb23706395a520d52af51ea2a441d972115d6cd85a9e4048d17424d0e7077e679cd23d6ec1a9f43f4fde1e6d29ab8670906dc27451b730f2dab4c5c753789f
-  data.tar.gz: 13209882976145efe8087a5c5d52e1980d5295c4b7ab51628dc92007f6b83900933fb2e08046bac7ccf118056289bba04f3f5597b70400c74c32969468e31409
+  metadata.gz: 38ecea1a966f361809d3e13440ee16acffd3bbf79d7629a48d65d3a5f5bc4474c51a8b79c1b8f54f9f2737ef4aa86105394e45caae9bd02f125874b8bc9d4496
+  data.tar.gz: 13520d3877d427ce2423576543688c9d91e0813bd12bf9e1e886dc65874cea527b04a88763867b7767d2cad03bfd5fc0745b22cc69c96dc140477e54b80c7b08

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## HEAD (unreleased)
 
+## 0.1.3
+
+- Internal refactor (https://github.com/zombocom/syntax_search/pull/13)
+
 ## 0.1.2
 
 - Codeblocks in output are now indented with 4 spaces and "code fences" are removed (https://github.com/zombocom/syntax_search/pull/11)

data/Gemfile

@@ -7,3 +7,4 @@ gemspec
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
+gem "stackprof"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    syntax_search (0.1.2)
+    syntax_search (0.1.3)
       parser
 
 GEM
@@ -25,6 +25,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.0)
+    stackprof (0.2.16)
 
 PLATFORMS
   ruby
@@ -32,6 +33,7 @@ PLATFORMS
 DEPENDENCIES
   rake (~> 12.0)
   rspec (~> 3.0)
+  stackprof
   syntax_search!
 
 BUNDLED WITH

data/lib/syntax_search.rb

@@ -40,6 +40,7 @@ module SyntaxErrorSearch
       blocks: blocks,
       filename: filename,
       terminal: terminal,
+      code_lines: search.code_lines,
       invalid_type: invalid_type(source),
       io: $stderr
     ).call
@@ -152,5 +153,9 @@ end
 require_relative "syntax_search/code_line"
 require_relative "syntax_search/code_block"
 require_relative "syntax_search/code_frontier"
-require_relative "syntax_search/code_search"
 require_relative "syntax_search/display_invalid_blocks"
+require_relative "syntax_search/around_block_scan"
+require_relative "syntax_search/block_expand"
+require_relative "syntax_search/parse_blocks_from_indent_line"
+
+require_relative "syntax_search/code_search"

data/lib/syntax_search/around_block_scan.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+#
+module SyntaxErrorSearch
+  # This class is useful for exploring contents before and after
+  # a block
+  #
+  # It searches above and below the passed in block to match for
+  # whatever criteria you give it:
+  #
+  # Example:
+  #
+  #   def dog
+  #     puts "bark"
+  #     puts "bark"
+  #   end
+  #
+  #   scan = AroundBlockScan.new(
+  #     code_lines: code_lines
+  #     block: CodeBlock.new(lines: code_lines[1])
+  #   )
+  #
+  #   scan.scan_while { true }
+  #
+  #   puts scan.before_index # => 0
+  #   puts scan.after_index # => 3
+  #
+  # Contents can also be filtered using AroundBlockScan#skip
+  #
+  # To grab the next surrounding indentation use AroundBlockScan#scan_adjacent_indent
+  class AroundBlockScan
+    def initialize(code_lines: , block:)
+      @code_lines = code_lines
+      @orig_before_index = block.lines.first.index
+      @orig_after_index = block.lines.last.index
+      @skip_array = []
+      @after_array = []
+      @before_array = []
+    end
+
+    def skip(name)
+      @skip_array << name
+      self
+    end
+
+    def scan_while(&block)
+      @before_index = before_lines.reverse_each.take_while do |line|
+        next true if @skip_array.detect {|meth| line.send(meth) }
+
+        block.call(line)
+      end.reverse.first&.index
+
+      @after_index = after_lines.take_while do |line|
+        next true if @skip_array.detect {|meth| line.send(meth) }
+
+        block.call(line)
+      end.last&.index
+      self
+    end
+
+    def scan_adjacent_indent
+      before_indent = @code_lines[@orig_before_index.pred]&.indent || 0
+      after_indent = @code_lines[@orig_after_index.next]&.indent || 0
+
+      indent = [before_indent, after_indent].min
+      @before_index = before_index.pred if before_indent >= indent
+      @after_index = after_index.next if after_indent >= indent
+
+      self
+    end
+
+    def code_block
+      CodeBlock.new(lines: @code_lines[before_index..after_index])
+    end
+
+    def before_index
+      @before_index || @orig_before_index
+    end
+
+    def after_index
+      @after_index || @orig_after_index
+    end
+
+    private def before_lines
+      @code_lines[0...@orig_before_index]
+    end
+
+    private def after_lines
+      @code_lines[@orig_after_index.next..-1]
+    end
+  end
+end

data/lib/syntax_search/block_expand.rb

@@ -0,0 +1,78 @@
+# 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)
+        .scan_adjacent_indent
+        .code_block
+
+      # Handle if/else/end case
+      if (next_block = expand_neighbors(block, grab_empty: false))
+        return next_block
+      else
+        return block
+      end
+    end
+
+    def expand_neighbors(block, grab_empty: true)
+      scan = AroundBlockScan.new(code_lines: @code_lines, block: block)
+        .skip(:hidden?)
+        .scan_while {|line| line.not_empty? && line.indent >= block.current_indent }
+
+      # 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/code_block.rb

@@ -3,11 +3,7 @@
 module SyntaxErrorSearch
   # Multiple lines form a singular CodeBlock
   #
-  # Source code is made of multiple CodeBlocks. A code block
-  # has a reference to the source code that created itself, this allows
-  # a code block to "expand" when needed
-  #
-  # The most important ability of a CodeBlock is this ability to expand:
+  # Source code is made of multiple CodeBlocks.
   #
   # Example:
   #
@@ -16,21 +12,19 @@ module SyntaxErrorSearch
   #     #     puts "foo"
   #     #   end
   #
-  #   code_block.expand_until_next_boundry
+  #   code_block.valid? # => true
+  #   code_block.in_valid? # => false
   #
-  #   code_block.to_s # =>
-  #     # class Foo
-  #     #   def foo
-  #     #     puts "foo"
-  #     #   end
-  #     # end
   #
   class CodeBlock
     attr_reader :lines
 
-    def initialize(code_lines: nil, lines: [])
+    def initialize(lines: [])
       @lines = Array(lines)
-      @code_lines = code_lines
+    end
+
+    def mark_invisible
+      @lines.map(&:mark_invisible)
     end
 
     def is_end?
@@ -38,11 +32,11 @@ module SyntaxErrorSearch
     end
 
     def starts_at
-      @lines.first&.line_number
+      @starts_at ||= @lines.first&.line_number
     end
 
-    def code_lines
-      @code_lines
+    def ends_at
+      @ends_at ||= @lines.last&.line_number
     end
 
     # This is used for frontier ordering, we are searching from
@@ -53,155 +47,8 @@ module SyntaxErrorSearch
       self.current_indent <=> other.current_indent
     end
 
-    # Only the lines that are not empty and visible
-    def visible_lines
-      @lines
-        .select(&:not_empty?)
-        .select(&:visible?)
-    end
-
-    # This method is used to expand a code block to capture it's calling context
-    def expand_until_next_boundry
-      expand_to_indent(next_indent)
-      self
-    end
-
-    # This method expands the given code block until it captures
-    # its nearest neighbors. This is used to expand a single line of code
-    # to its smallest likely block.
-    #
-    #   code_block.to_s # =>
-    #     #     puts "foo"
-    #   code_block.expand_until_neighbors
-    #
-    #   code_block.to_s # =>
-    #     #     puts "foo"
-    #     #     puts "bar"
-    #     #     puts "baz"
-    #
-    def expand_until_neighbors
-      expand_to_indent(current_indent)
-
-      expand_hidden_parner_line if self.to_s.strip == "end"
-      self
-    end
-
-    def expand_hidden_parner_line
-      index = @lines.first.index
-      indent = current_indent
-      partner_line  = code_lines.select {|line| line.index < index && line.indent == indent }.last
-
-      if partner_line&.hidden?
-        partner_line.mark_visible
-        @lines.prepend(partner_line)
-      end
-    end
-
-    # This method expands the existing code block up (before)
-    # and down (after). It will break on change in indentation
-    # and empty lines.
-    #
-    #   code_block.to_s # =>
-    #     #   def foo
-    #     #     puts "foo"
-    #     #   end
-    #
-    #   code_block.expand_to_indent(0)
-    #   code_block.to_s # =>
-    #     # class Foo
-    #     #   def foo
-    #     #     puts "foo"
-    #     #   end
-    #     # end
-    #
-    private def expand_to_indent(indent)
-      array = []
-      before_lines(skip_empty: false).each do |line|
-        if line.empty?
-          array.prepend(line)
-          break
-        end
-
-        if line.indent == indent
-          array.prepend(line)
-        else
-          break
-        end
-      end
-
-      array << @lines
-
-      after_lines(skip_empty: false).each do |line|
-        if line.empty?
-          array << line
-          break
-        end
-
-        if line.indent == indent
-          array << line
-        else
-          break
-        end
-      end
-
-      @lines = array.flatten
-    end
-
-    def next_indent
-      [
-        before_line&.indent || 0,
-        after_line&.indent || 0
-      ].max
-    end
-
     def current_indent
-      lines.detect(&:not_empty?)&.indent || 0
-    end
-
-    def before_line
-      before_lines.first
-    end
-
-    def after_line
-      after_lines.first
-    end
-
-    def before_lines(skip_empty: true)
-      index = @lines.first.index
-      lines = code_lines.select {|line| line.index < index }
-      lines.select!(&:not_empty?) if skip_empty
-      lines.select!(&:visible?)
-      lines.reverse!
-
-      lines
-    end
-
-    def after_lines(skip_empty: true)
-      index = @lines.last.index
-      lines = code_lines.select {|line| line.index > index }
-      lines.select!(&:not_empty?) if skip_empty
-      lines.select!(&:visible?)
-      lines
-    end
-
-    # Returns a code block of the source that does not include
-    # the current lines. This is useful for checking if a source
-    # with the given lines removed parses successfully. If so
-    #
-    # Then it's proof that the current block is invalid
-    def block_without
-      @block_without ||= CodeBlock.new(
-        source: @source,
-        lines: @source.code_lines - @lines
-      )
-    end
-
-    def document_valid_without?
-      block_without.valid?
-    end
-
-    def valid_without?
-      block_without.valid?
+      @current_indent ||= lines.select(&:not_empty?).map(&:indent).min || 0
     end
 
     def invalid?

data/lib/syntax_search/code_frontier.rb

@@ -1,178 +1,43 @@
 # frozen_string_literal: true
 
 module SyntaxErrorSearch
-  # This class is responsible for generating, storing, and sorting code blocks
+  # The main function of the frontier is to hold the edges of our search and to
+  # evaluate when we can stop searching.
   #
-  # The search algorithm for finding our syntax errors isn't in this class, but
-  # this is class holds the bulk of the logic for generating, storing, detecting
-  # and filtering invalid code.
+  # ## Knowing where we've been
   #
-  # This is loosely based on the idea of a "frontier" for searching for a path
-  # example: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
+  # 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.
   #
-  # In this case our path is going from code with a syntax error to code without a
-  # syntax error. We're currently doing that by evaluating individual lines
-  # with respect to indentation and other whitespace (empty lines). As represented
-  # by individual "code blocks".
+  #   CodeFrontier#<<
+  #   CodeFrontier#pop
   #
-  # This class does not just store the frontier that we're searching, but is responsible
-  # for generating new code blocks as well. This is not ideal, but the state of generating
-  # and evaluating paths i.e. codeblocks is very tightly coupled.
+  # ## Knowing where we can go
   #
-  # ## Creation
+  # 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 example code is re-used in the other sections
+  # 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.
   #
-  # Example:
+  #   CodeFrontier#next_indent_line
+  #   CodeFrontier#register_indent_block
   #
-  #   code_lines = [
-  #     CodeLine.new(line: "def cinco\n", index: 0)
-  #     CodeLine.new(line: "  def dog\n", index: 1) # Syntax error 1
-  #     CodeLine.new(line: "  def cat\n", index: 2) # Syntax error 2
-  #     CodeLine.new(line: "end\n",       index: 3)
-  #   ]
+  # ## Knowing when to stop
   #
-  #   frontier = CodeFrontier.new(code_lines: code_lines)
+  # The frontier holds the syntax error when removing all code blocks from the original
+  # source document allows it to be parsed as syntatically valid:
   #
-  #   frontier << frontier.next_block if frontier.next_block?
-  #   frontier << frontier.next_block if frontier.next_block?
+  #   CodeFrontier#holds_all_syntax_errors?
   #
-  #   frontier.holds_all_syntax_errors? # => true
-  #   block = frontier.pop
-  #   frontier.holds_all_syntax_errors? # => false
-  #   frontier << block
-  #   frontier.holds_all_syntax_errors? # => true
+  # ## Filtering false positives
   #
-  #   frontier.detect_invalid_blocks.map(&:to_s) # =>
-  #   [
-  #     "def dog\n",
-  #     "def cat\n"
-  #   ]
+  # 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:
   #
-  # ## Block Generation
-  #
-  # Currently code blocks are generated based off of indentation. With the idea that blocks are,
-  # well, indented. Once a code block is added to the frontier or it is expanded, or it is generated
-  # then we also need to remove those lines from our generation code so we don't generate the same block
-  # twice by accident.
-  #
-  # This is block generation is currently done via the "indent_hash" internally by starting at the outer
-  # most indentation.
-  #
-  # Example:
-  #
-  #   ```
-  #   def river
-  #     puts "lol" # <=== Start looking here and expand outwards
-  #   end
-  #   ```
-  #
-  # Generating new code blocks is a little verbose but looks like this:
-  #
-  #   frontier << frontier.next_block if frontier.next_block?
-  #
-  # Once a block is in the frontier, it can be popped off:
-  #
-  #   frontier.pop
-  #   # => <# CodeBlock >
-  #
-  # ## Block (frontier) storage, ordering and retrieval
-  #
-  # Once a block is generated it is stored internally in a frontier array. This is very similar to a search algorithm.
-  # The array is sorted by indentation order, so that when a block is popped off the array, the one with
-  # the largest current indentation is evaluated first.
-  #
-  # For example, if we have these two blocks in the frontier:
-  #
-  #   ```
-  #   # Block A - 0 spaces for indentation
-  #
-  #   def cinco
-  #     puts "lol"
-  #   end
-  #   ```
-  #
-  #   ```
-  #   # Block B - 2 spaces for indentation
-  #
-  #     def river
-  #       puts "hehe"
-  #     end
-  #   ```
-  #
-  # The "Block B" has more current indentation, so it would be evaluated first.
-  #
-  # ## Frontier evaluation (Find the syntax error)
-  #
-  # Another key difference between this and a normal search "frontier" is that we're not checking if
-  # an individual code block meets the goal (turning invalid code to valid code) since there can
-  # be multiple syntax errors and this will require multiple code blocks. To handle this, we're
-  # evaluating all the contents of the frontier at the same time to see if the solution exists in any
-  # of our search blocks.
-  #
-  #   # Using the previously generated frontier
-  #
-  #   frontier << Block.new(lines: code_lines[1], code_lines: code_lines)
-  #   frontier.holds_all_syntax_errors? # => false
-  #
-  #   frontier << Block.new(lines: code_lines[2], code_lines: code_lines)
-  #   frontier.holds_all_syntax_errors? # => true
-  #
-  # ## Detect invalid blocks (Filter for smallest solution)
-  #
-  # After we prove that a solution exists and we've found it to be in our frontier, we can start stop searching.
-  # Once we've done this, we need to search through the existing frontier code blocks to find the minimum combination
-  # of blocks that hold the solution. This is done in: `detect_invalid_blocks`.
-  #
-  #   # Using the previously generated frontier
-  #
-  #   frontier << CodeBlock.new(lines: code_lines[0], code_lines: code_lines)
-  #   frontier << CodeBlock.new(lines: code_lines[1], code_lines: code_lines)
-  #   frontier << CodeBlock.new(lines: code_lines[2], code_lines: code_lines)
-  #   frontier << CodeBlock.new(lines: code_lines[3], code_lines: code_lines)
-  #
-  #   frontier.count # => 4
-  #   frontier.detect_invalid_blocks.length => 2
-  #   frontier.detect_invalid_blocks.map(&:to_s) # =>
-  #   [
-  #     "def dog\n",
-  #     "def cat\n"
-  #   ]
-  #
-  # Once invalid blocks are found and filtered, then they can be passed to a formatter.
-  #
-  #
-  #
-
-  class IndentScan
-    attr_reader :code_lines
-
-    def initialize(code_lines: )
-      @code_lines = code_lines
-    end
-
-    def neighbors_from_top(top_line)
-      code_lines
-        .select {|l| l.index >= top_line.index }
-        .select {|l| l.not_empty? }
-        .select {|l| l.visible? }
-        .take_while {|l| l.indent >= top_line.indent }
-    end
-
-    def each_neighbor_block(top_line)
-      neighbors = neighbors_from_top(top_line)
-
-      until neighbors.empty?
-        lines = [neighbors.pop]
-        while (block = CodeBlock.new(lines: lines, code_lines: code_lines)) && block.invalid? && neighbors.any?
-          lines.prepend neighbors.pop
-        end
-
-        yield block if block
-      end
-    end
-  end
-
+  #   CodeFrontier#detect_invalid_blocks
   class CodeFrontier
     def initialize(code_lines: )
       @code_lines = code_lines
@@ -207,16 +72,9 @@ module SyntaxErrorSearch
 
     # Returns a code block with the largest indentation possible
     def pop
-      return nil if empty?
-
       return @frontier.pop
     end
 
-    def next_block?
-      !@indent_hash.empty?
-    end
-
-
     def indent_hash_indent
       @indent_hash.keys.sort.last
     end
@@ -226,40 +84,25 @@ module SyntaxErrorSearch
       @indent_hash[indent]&.first
     end
 
-    def generate_blocks
-    end
-
-    def next_block
-      indent = @indent_hash.keys.sort.last
-      lines = @indent_hash[indent].first
-
-      block = CodeBlock.new(
-        lines: lines,
-        code_lines: @code_lines
-      ).expand_until_neighbors
-
-      register(block)
-      block
-    end
-
     def expand?
       return false if @frontier.empty?
       return true if @indent_hash.empty?
 
-      @frontier.last.current_indent >= @indent_hash.keys.sort.last
-    end
+      frontier_indent = @frontier.last.current_indent
+      hash_indent = @indent_hash.keys.sort.last
 
-    # This method is responsible for determining if a new code
-    # block should be generated instead of evaluating an already
-    # existing block in the frontier
-    def generate_new_block?
-      return false if @indent_hash.empty?
-      return true if @frontier.empty?
+      if ENV["DEBUG"]
+        puts "```"
+        puts @frontier.last.to_s
+        puts "```"
+        puts "  @frontier indent: #{frontier_indent}"
+        puts "  @hash indent:     #{hash_indent}"
+      end
 
-      @frontier.last.current_indent <= @indent_hash.keys.sort.last
+      frontier_indent >= hash_indent
     end
 
-    def register(block)
+    def register_indent_block(block)
       block.lines.each do |line|
         @indent_hash[line.indent]&.delete(line)
       end
@@ -273,22 +116,18 @@ module SyntaxErrorSearch
     # 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(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
 
-    def any?
-      !empty?
-    end
-
-    def empty?
-      @frontier.empty? && @indent_hash.empty?
-    end
-
     # Example:
     #
     #   combination([:a, :b, :c, :d])

data/lib/syntax_search/code_search.rb

@@ -3,15 +3,16 @@
 module SyntaxErrorSearch
   # Searches code for a syntax error
   #
-  # The bulk of the heavy lifting is done by the CodeFrontier
+  # The bulk of the heavy lifting is done in:
   #
-  # The flow looks like this:
+  #  - 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
@@ -23,7 +24,6 @@ module SyntaxErrorSearch
   #   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
@@ -41,24 +41,33 @@ module SyntaxErrorSearch
       @invalid_blocks = []
       @name_tick = Hash.new {|hash, k| hash[k] = 0 }
       @tick = 0
-      @scan = IndentScan.new(code_lines: @code_lines)
+      @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
+          terminal: false,
+          code_lines: @code_lines,
         )
         f.write(display.indent display.code_with_lines)
       end
     end
 
-    def push_if_invalid(block, name: )
-      frontier.register(block)
+    def push(block, name: )
       record(block: block, name: name)
 
       if block.valid?
@@ -69,32 +78,36 @@ module SyntaxErrorSearch
       end
     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)
-        neighbors = @scan.neighbors_from_top(frontier.next_indent_line)
 
-        @scan.each_neighbor_block(frontier.next_indent_line) do |block|
+        @parse_blocks_from_indent_line.each_neighbor_block(frontier.next_indent_line) do |block|
           record(block: block, name: "add")
-          if block.valid?
-            block.lines.each(&:mark_invisible)
-          end
-        end
 
-        block = CodeBlock.new(lines: neighbors, code_lines: @code_lines)
-        push_if_invalid(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
 
-      block.expand_until_next_boundry
-      push_if_invalid(block, name: "expand")
+      record(block: block, name: "pop")
+
+      # block = block.expand_until_next_boundry
+      block = @block_expand.call(block)
+      push(block, name: "expand")
     end
 
+    # Main search loop
     def call
       until frontier.holds_all_syntax_errors?
         @tick += 1

data/lib/syntax_search/display_invalid_blocks.rb

@@ -5,14 +5,14 @@ module SyntaxErrorSearch
   class DisplayInvalidBlocks
     attr_reader :filename
 
-    def initialize(blocks:, io: $stderr, filename: nil, terminal: false, invalid_type: :unmatched_end)
+    def initialize(code_lines: ,blocks:, io: $stderr, filename: nil, terminal: false, invalid_type: :unmatched_end)
       @terminal = terminal
       @filename = filename
       @io = io
 
       @blocks = Array(blocks)
       @lines = @blocks.map(&:lines).flatten
-      @code_lines = @blocks.first&.code_lines || []
+      @code_lines = code_lines
       @digit_count = @code_lines.last&.line_number.to_s.length
 
       @invalid_line_hash = @lines.each_with_object({}) {|line, h| h[line] = true  }

data/lib/syntax_search/parse_blocks_from_indent_line.rb

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

data/lib/syntax_search/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxErrorSearch
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_search
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - schneems
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-12 00:00:00.000000000 Z
+date: 2020-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -49,13 +49,16 @@ files:
 - bin/setup
 - exe/syntax_search
 - lib/syntax_search.rb
+- lib/syntax_search/around_block_scan.rb
 - lib/syntax_search/auto.rb
+- lib/syntax_search/block_expand.rb
 - lib/syntax_search/code_block.rb
 - lib/syntax_search/code_frontier.rb
 - lib/syntax_search/code_line.rb
 - lib/syntax_search/code_search.rb
 - lib/syntax_search/display_invalid_blocks.rb
 - lib/syntax_search/fyi.rb
+- lib/syntax_search/parse_blocks_from_indent_line.rb
 - lib/syntax_search/version.rb
 - syntax_search.gemspec
 homepage: https://github.com/zombocom/syntax_search.git