WIP Tree and heuristic based re-write

Gemfile.lock

@@ -45,7 +45,7 @@ GEM
       rubocop-ast (>= 0.4.0)
     ruby-prof (1.4.3)
     ruby-progressbar (1.11.0)
-    stackprof (0.2.16)
+    stackprof (0.2.17)
     standard (1.3.0)
       rubocop (= 1.20.0)
       rubocop-performance (= 1.11.5)

lib/dead_end/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "version"
 
 require "tmpdir"
@@ -60,6 +62,41 @@ def self.handle_error(e, re_raise: true, io: $stderr)
   #
   # Main private interface
   def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)
+    call_now(source: source, filename: filename, terminal: terminal, record_dir: record_dir, timeout: timeout, io: io)
+    # call_old(source: source, filename: filename, terminal: terminal, record_dir: record_dir, timeout: timeout, io: io)
+  end
+
+  def self.call_now(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)
+    search = nil
+    code_lines = nil
+    filename = nil if filename == DEFAULT_VALUE
+    Timeout.timeout(timeout) do
+      code_lines = CleanDocument.new(source: source).call.lines
+
+      if DeadEnd.valid?(code_lines)
+        io.puts "Syntax OK"
+        obj = Object.new
+        def obj.document_ok?; true; end
+        return obj
+      end
+
+      document = BlockDocument.new(code_lines: code_lines).call
+      tree = IndentTree.new(document: document).call
+      search = IndentSearch.new(tree: tree).call
+    end
+
+    blocks = search.finished.map(&:node).map {|node| CodeBlock.new(lines: node.lines) }
+
+    DisplayInvalidBlocks.new(
+      io: io,
+      blocks: blocks,
+      filename: filename,
+      terminal: terminal,
+      code_lines: code_lines,
+    ).call
+  end
+
+  def self.call_old(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_dir: DEFAULT_VALUE, timeout: TIMEOUT_DEFAULT, io: $stderr)
     search = nil
     filename = nil if filename == DEFAULT_VALUE
     Timeout.timeout(timeout) do
@@ -73,7 +110,7 @@ def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_
       blocks: blocks,
       filename: filename,
       terminal: terminal,
-      code_lines: search.code_lines
+      code_lines: search.code_lines,
     ).call
   rescue Timeout::Error => e
     io.puts "Search timed out DEAD_END_TIMEOUT=#{timeout}, run with DEBUG=1 for more info"
@@ -85,13 +122,15 @@ def self.call(source:, filename: DEFAULT_VALUE, terminal: DEFAULT_VALUE, record_
   # Used to generate a unique directory to record
   # search steps for debugging
   def self.record_dir(dir)
-    time = Time.now.strftime("%Y-%m-%d-%H-%M-%s-%N")
-    dir = Pathname(dir)
-    symlink = dir.join("last").tap { |path| path.delete if path.exist? }
-    dir.join(time).tap { |path|
-      path.mkpath
-      FileUtils.symlink(path.basename, symlink)
-    }
+    @record_dir ||= begin
+      time = Time.now.strftime("%Y-%m-%d-%H-%M-%s-%N")
+      dir = Pathname(dir)
+      symlink = dir.join("last").tap { |path| path.delete if path.exist? }
+      dir.join(time).tap { |path|
+        path.mkpath
+        FileUtils.symlink(path.basename, symlink)
+      }
+    end
   end
 
   # DeadEnd.valid_without? [Private]
@@ -187,12 +226,20 @@ def self.valid?(source)
 require_relative "lex_all"
 require_relative "code_line"
 require_relative "code_block"
-require_relative "block_expand"
+require_relative "lex_pair_diff"
 require_relative "ripper_errors"
 require_relative "priority_queue"
 require_relative "unvisited_lines"
 require_relative "around_block_scan"
+require_relative "indent_block_expand"
 require_relative "priority_engulf_queue"
 require_relative "pathname_from_message"
 require_relative "display_invalid_blocks"
 require_relative "parse_blocks_from_indent_line"
+
+require_relative "block_node"
+require_relative "indent_tree"
+require_relative "block_document"
+
+require_relative "indent_search"
+require_relative "diagnose_node"

lib/dead_end/around_block_scan.rb

@@ -121,7 +121,7 @@ def capture_neighbor_context
           break
         end
 
-        lines << line
+        lines << line if line.is_kw? || line.is_end?
       end
 
       lines.reverse!
@@ -140,7 +140,7 @@ def capture_neighbor_context
           break
         end
 
-        lines << line
+        lines << line if line.is_kw? || line.is_end?
       end
 
       lines

lib/dead_end/block_document.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module DeadEnd
+  # Convert an array of code lines to a linked list of BlockNodes
+  #
+  # Each BlockNode is connected to the node above and below it.
+  # A BlockNode can "capture" other nodes. This process is recursively
+  # performed to build a hierarchical tree structure via IndentTree
+  #
+  #   document = BlockDocument.new(code_lines: code_lines)
+  #   document.call
+  #
+  # A BlockDocument also holds a priority queue for all BlockNodes
+  #
+  # Empty lines are ignored so blocks in the list may have gaps in
+  # line/index numbers.
+  #
+  # A core operation is the ability to to "capture"
+  # several blocks immutably. This process creates a new block
+  # that holds the captured state and substitutes it into the graph
+  # data structure for the original block
+  #
+  #   node.above.leaning # => :left
+  #   node.below.leaning # => :right
+
+  #   block = document.capture_all([node.above, node.below])
+  #   block.leaning # => :equal
+  #
+  class BlockDocument
+    attr_reader :blocks, :queue, :root, :code_lines
+
+    include Enumerable
+
+    def initialize(code_lines:)
+      @code_lines = code_lines
+      @queue = InsertionSortQueue.new
+      @root = nil
+    end
+
+    def to_a
+      map(&:itself)
+    end
+
+    def each
+      node = @root
+      while node
+        yield node
+        node = node.below
+      end
+    end
+
+    def to_s
+      string = +""
+      each do |block|
+        string << block.to_s
+      end
+      string
+    end
+
+    def call
+      last = nil
+      blocks = @code_lines.filter_map do |line|
+        next if line.empty?
+
+        node = BlockNode.new(lines: line, indent: line.indent)
+        @root ||= node
+        node.above = last
+        last&.below = node
+        last = node
+        node
+      end
+
+      if last.above
+        last.above.below = last
+      end
+
+      # Need all above/below set to determine correct next_indent
+      @queue.replace(blocks.sort)
+
+      self
+    end
+
+    def capture_all(inner)
+      now = BlockNode.from_blocks(inner)
+      while queue&.peek&.deleted?
+        queue.pop
+      end
+
+      if inner.first == @root
+        @root = now
+      end
+
+      if inner.first&.above
+        inner.first.above.below = now
+        now.above = inner.first.above
+      end
+
+      if inner.last&.below
+        inner.last.below.above = now
+        now.below = inner.last.below
+      end
+      now
+    end
+
+    def capture(node:, captured:)
+      inner = []
+      inner.concat(Array(captured))
+      inner << node
+      inner.sort_by! { |block| block.start_index }
+
+      capture_all(inner)
+    end
+
+    def pop
+      @queue.pop
+    end
+
+    def peek
+      @queue.peek
+    end
+
+    def inspect
+      "#<DeadEnd::BlockDocument:0x000000010b375lol >"
+    end
+  end
+end