parsanol 3.0.0

data/spec/parsanol/interval_tree_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+require 'parsanol/interval_tree'
+
+describe Parsanol::IntervalTree do
+  let(:tree) { Parsanol::IntervalTree.new }
+
+  describe '#initialize' do
+    it 'creates an empty tree' do
+      expect(tree.empty?).to be true
+      expect(tree.size).to eq 0
+    end
+  end
+
+  describe '#insert and #query_exact' do
+    it 'inserts and retrieves a single interval' do
+      tree.insert(0, 10, 'data1')
+      expect(tree.size).to eq 1
+      expect(tree.query_exact(0, 10)).to eq 'data1'
+    end
+
+    it 'returns nil for non-existent intervals' do
+      tree.insert(0, 10, 'data1')
+      expect(tree.query_exact(0, 5)).to be_nil
+      expect(tree.query_exact(5, 10)).to be_nil
+    end
+
+    it 'handles multiple insertions' do
+      tree.insert(0, 10, 'data1')
+      tree.insert(20, 30, 'data2')
+      tree.insert(10, 20, 'data3')
+
+      expect(tree.size).to eq 3
+      expect(tree.query_exact(0, 10)).to eq 'data1'
+      expect(tree.query_exact(20, 30)).to eq 'data2'
+      expect(tree.query_exact(10, 20)).to eq 'data3'
+    end
+  end
+
+  describe '#query_overlapping' do
+    before do
+      # Create intervals: [0,10), [5,15), [20,30), [25,35)
+      tree.insert(0, 10, 'interval1')
+      tree.insert(5, 15, 'interval2')
+      tree.insert(20, 30, 'interval3')
+      tree.insert(25, 35, 'interval4')
+    end
+
+    it 'finds intervals that overlap with query range' do
+      # Query [0,5) should overlap with [0,10)
+      results = tree.query_overlapping(0, 5)
+      expect(results).to include('interval1')
+      expect(results.size).to eq 1
+    end
+
+    it 'finds multiple overlapping intervals' do
+      # Query [7,12) should overlap with [0,10) and [5,15)
+      results = tree.query_overlapping(7, 12)
+      expect(results).to include('interval1', 'interval2')
+      expect(results.size).to eq 2
+    end
+
+    it 'returns empty array when no overlaps' do
+      # Query [15,20) should have no overlaps
+      results = tree.query_overlapping(15, 20)
+      expect(results).to be_empty
+    end
+
+    it 'finds overlaps at boundaries' do
+      # Query [22,28) should overlap with [20,30) and [25,35)
+      results = tree.query_overlapping(22, 28)
+      expect(results).to include('interval3', 'interval4')
+      expect(results.size).to eq 2
+    end
+
+    it 'handles query that encompasses multiple intervals' do
+      # Query [0,40) should overlap with all intervals
+      results = tree.query_overlapping(0, 40)
+      expect(results.size).to eq 4
+    end
+
+    it 'handles point queries (zero-length intervals)' do
+      # Query [8,8) is empty, should have no overlaps
+      results = tree.query_overlapping(8, 8)
+      expect(results).to be_empty
+    end
+  end
+
+  describe '#delete_overlapping' do
+    before do
+      tree.insert(0, 10, 'interval1')
+      tree.insert(5, 15, 'interval2')
+      tree.insert(20, 30, 'interval3')
+      tree.insert(25, 35, 'interval4')
+    end
+
+    it 'deletes overlapping intervals' do
+      # Delete intervals overlapping with [7,12)
+      deleted = tree.delete_overlapping(7, 12)
+
+      expect(deleted).to include('interval1', 'interval2')
+      expect(deleted.size).to eq 2
+      expect(tree.size).to eq 2
+
+      # Verify they're actually deleted
+      expect(tree.query_exact(0, 10)).to be_nil
+      expect(tree.query_exact(5, 15)).to be_nil
+
+      # Verify others remain
+      expect(tree.query_exact(20, 30)).to eq 'interval3'
+      expect(tree.query_exact(25, 35)).to eq 'interval4'
+    end
+
+    it 'returns empty array when no overlaps to delete' do
+      deleted = tree.delete_overlapping(15, 20)
+      expect(deleted).to be_empty
+      expect(tree.size).to eq 4
+    end
+
+    it 'can delete all intervals' do
+      deleted = tree.delete_overlapping(0, 40)
+      expect(deleted.size).to eq 4
+      expect(tree.empty?).to be true
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all intervals' do
+      tree.insert(0, 10, 'data1')
+      tree.insert(20, 30, 'data2')
+
+      tree.clear
+
+      expect(tree.empty?).to be true
+      expect(tree.size).to eq 0
+      expect(tree.query_exact(0, 10)).to be_nil
+    end
+  end
+
+  describe 'complex scenarios' do
+    it 'handles many intervals efficiently' do
+      # Insert 100 intervals
+      100.times do |i|
+        tree.insert(i * 10, i * 10 + 15, "data#{i}")
+      end
+
+      expect(tree.size).to eq 100
+
+      # Query should find overlapping intervals efficiently
+      results = tree.query_overlapping(50, 65)
+      expect(results.size).to be > 0
+    end
+
+    it 'handles overlapping insertions correctly' do
+      tree.insert(0, 100, 'big')
+      tree.insert(10, 20, 'small1')
+      tree.insert(30, 40, 'small2')
+      tree.insert(50, 60, 'small3')
+
+      # Query in middle should find big + one small
+      results = tree.query_overlapping(15, 25)
+      expect(results).to include('big', 'small1')
+      expect(results.size).to eq 2
+    end
+
+    it 'maintains correctness after deletions' do
+      # Insert intervals
+      tree.insert(0, 10, 'a')
+      tree.insert(20, 30, 'b')
+      tree.insert(40, 50, 'c')
+      tree.insert(60, 70, 'd')
+
+      # Delete middle range - should delete b and c
+      deleted = tree.delete_overlapping(15, 55)
+
+      # Should have deleted b and c
+      expect(deleted).to include('b', 'c')
+      expect(deleted.size).to eq 2
+      expect(tree.query_exact(20, 30)).to be_nil
+      expect(tree.query_exact(40, 50)).to be_nil
+
+      # Should still have a and d
+      expect(tree.query_exact(0, 10)).to eq 'a'
+      expect(tree.query_exact(60, 70)).to eq 'd'
+    end
+  end
+
+  describe 'edge cases' do
+    it 'handles zero-length intervals' do
+      tree.insert(10, 10, 'zero-length')
+      expect(tree.size).to eq 1
+      expect(tree.query_exact(10, 10)).to eq 'zero-length'
+    end
+
+    it 'handles large position values' do
+      large_pos = 1_000_000
+      tree.insert(large_pos, large_pos + 100, 'large')
+      expect(tree.query_exact(large_pos, large_pos + 100)).to eq 'large'
+    end
+
+    it 'handles negative positions' do
+      tree.insert(-10, 0, 'negative')
+      expect(tree.query_exact(-10, 0)).to eq 'negative'
+    end
+  end
+end

data/spec/parsanol/lazy_result_spec.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Parsanol::LazyResult do
+  let(:context) { Parsanol::Atoms::Context.new }
+  let(:buffer) do
+    buf = context.acquire_buffer(size: 4)
+    buf.push("a")
+    buf.push("b")
+    buf.push("c")
+    buf
+  end
+  let(:lazy) { described_class.new(buffer, context) }
+
+  describe '#initialize' do
+    it 'stores buffer and context' do
+      expect(lazy.buffer).to eq(buffer)
+      expect(lazy.context).to eq(context)
+      expect(lazy.materialized).to be_nil
+    end
+  end
+
+  describe '#to_a' do
+    it 'materializes buffer to array' do
+      result = lazy.to_a
+      expect(result).to be_a(Array)
+      expect(result).to eq(["a", "b", "c"])
+    end
+    
+    it 'caches materialized array' do
+      arr1 = lazy.to_a
+      arr2 = lazy.to_a
+      expect(arr2.object_id).to eq(arr1.object_id)
+    end
+    
+    it 'only materializes once' do
+      expect(buffer).to receive(:to_a).once.and_call_original
+      lazy.to_a
+      lazy.to_a
+      lazy.to_a
+    end
+  end
+
+  describe '#[]' do
+    it 'accesses elements by index' do
+      expect(lazy[0]).to eq("a")
+      expect(lazy[1]).to eq("b")
+      expect(lazy[2]).to eq("c")
+    end
+    
+    it 'materializes on first access' do
+      expect(lazy.materialized).to be_nil
+      lazy[0]
+      expect(lazy.materialized).not_to be_nil
+    end
+    
+    it 'returns nil for out of bounds index' do
+      expect(lazy[10]).to be_nil
+    end
+  end
+
+  describe '#size' do
+    it 'returns buffer size without materializing' do
+      expect(lazy.size).to eq(3)
+      expect(lazy.materialized).to be_nil
+    end
+  end
+
+  describe '#length' do
+    it 'returns buffer size without materializing' do
+      expect(lazy.length).to eq(3)
+      expect(lazy.materialized).to be_nil
+    end
+  end
+
+  describe '#empty?' do
+    it 'returns false for non-empty buffer' do
+      expect(lazy.empty?).to be false
+      expect(lazy.materialized).to be_nil
+    end
+    
+    it 'returns true for empty buffer' do
+      empty_buffer = context.acquire_buffer(size: 2)
+      empty_lazy = described_class.new(empty_buffer, context)
+      expect(empty_lazy.empty?).to be true
+    end
+  end
+
+  describe '#each' do
+    it 'iterates over elements' do
+      result = []
+      lazy.each { |e| result << e }
+      expect(result).to eq(["a", "b", "c"])
+    end
+    
+    it 'returns enumerator without block' do
+      enum = lazy.each
+      expect(enum).to be_a(Enumerator)
+      expect(enum.to_a).to eq(["a", "b", "c"])
+    end
+    
+    it 'returns self when block given' do
+      result = lazy.each { |e| }
+      expect(result).to eq(lazy)
+    end
+  end
+
+  describe '#is_a?' do
+    it 'reports as Array' do
+      expect(lazy.is_a?(Array)).to be true
+    end
+    
+    it 'reports as LazyResult' do
+      expect(lazy.is_a?(Parsanol::LazyResult)).to be true
+    end
+    
+    it 'reports as Object' do
+      expect(lazy.is_a?(Object)).to be true
+    end
+  end
+
+  describe '#kind_of?' do
+    it 'is an alias for is_a?' do
+      expect(lazy.kind_of?(Array)).to be true
+      expect(lazy.kind_of?(Parsanol::LazyResult)).to be true
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'responds to array methods' do
+      expect(lazy.respond_to?(:map)).to be true
+      expect(lazy.respond_to?(:select)).to be true
+      expect(lazy.respond_to?(:first)).to be true
+      expect(lazy.respond_to?(:last)).to be true
+    end
+    
+    it 'responds to LazyResult methods' do
+      expect(lazy.respond_to?(:to_a)).to be true
+      expect(lazy.respond_to?(:size)).to be true
+      expect(lazy.respond_to?(:empty?)).to be true
+    end
+  end
+
+  describe '#method_missing' do
+    it 'delegates map to materialized array' do
+      expect(lazy.map { |e| e.upcase }).to eq(["A", "B", "C"])
+    end
+    
+    it 'delegates select to materialized array' do
+      expect(lazy.select { |e| e > "a" }).to eq(["b", "c"])
+    end
+    
+    it 'delegates first to materialized array' do
+      expect(lazy.first).to eq("a")
+    end
+    
+    it 'delegates last to materialized array' do
+      expect(lazy.last).to eq("c")
+    end
+    
+    it 'delegates join to materialized array' do
+      expect(lazy.join(", ")).to eq("a, b, c")
+    end
+    
+    it 'raises NoMethodError for unknown methods' do
+      expect { lazy.unknown_method }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#respond_to_missing?' do
+    it 'returns true for array methods' do
+      expect(lazy.respond_to?(:map)).to be true
+      expect(lazy.respond_to?(:flatten)).to be true
+    end
+    
+    it 'returns false for non-existent methods' do
+      expect(lazy.respond_to?(:nonexistent_method)).to be false
+    end
+  end
+
+  describe '#==' do
+    it 'compares equal to array with same content' do
+      expect(lazy == ["a", "b", "c"]).to be true
+      expect(lazy).to eq(["a", "b", "c"])
+    end
+    
+    it 'compares not equal to array with different content' do
+      expect(lazy == ["x", "y", "z"]).to be false
+      expect(lazy).not_to eq(["x", "y", "z"])
+    end
+    
+    it 'compares equal to another LazyResult with same content' do
+      buffer2 = context.acquire_buffer(size: 4)
+      buffer2.push("a")
+      buffer2.push("b")
+      buffer2.push("c")
+      lazy2 = described_class.new(buffer2, context)
+      
+      expect(lazy == lazy2).to be true
+      expect(lazy).to eq(lazy2)
+    end
+    
+    it 'works with rspec eq matcher' do
+      expect(lazy).to eq(["a", "b", "c"])
+    end
+  end
+
+  describe '#eql?' do
+    it 'is an alias for ==' do
+      expect(lazy.eql?(["a", "b", "c"])).to be true
+    end
+  end
+
+  describe '#hash' do
+    it 'returns same hash as equivalent array' do
+      array = ["a", "b", "c"]
+      expect(lazy.hash).to eq(array.hash)
+    end
+  end
+
+  describe 'materialization behavior' do
+    it 'defers materialization until needed' do
+      new_lazy = described_class.new(buffer, context)
+      expect(new_lazy.materialized).to be_nil
+      
+      # These don't materialize
+      new_lazy.size
+      new_lazy.empty?
+      new_lazy.length
+      expect(new_lazy.materialized).to be_nil
+      
+      # This does materialize
+      new_lazy.to_a
+      expect(new_lazy.materialized).not_to be_nil
+    end
+    
+    it 'materializes on array method calls' do
+      new_lazy = described_class.new(buffer, context)
+      expect(new_lazy.materialized).to be_nil
+      
+      # Array access materializes
+      new_lazy[0]
+      expect(new_lazy.materialized).not_to be_nil
+    end
+    
+    it 'materializes on enumerable methods' do
+      new_lazy = described_class.new(buffer, context)
+      expect(new_lazy.materialized).to be_nil
+      
+      # map materializes
+      new_lazy.map { |x| x }
+      expect(new_lazy.materialized).not_to be_nil
+    end
+  end
+
+  describe '#inspect' do
+    it 'shows buffer size when not materialized' do
+      new_lazy = described_class.new(buffer, context)
+      expect(new_lazy.inspect).to include("buffer.size=3")
+      expect(new_lazy.inspect).not_to include("materialized=")
+    end
+    
+    it 'shows materialized array after materialization' do
+      lazy.to_a
+      expect(lazy.inspect).to include("materialized=")
+      expect(lazy.inspect).to include('["a", "b", "c"]')
+    end
+  end
+
+  describe 'integration with parsing' do
+    it 'can be used in place of arrays' do
+      # LazyResult should act like an array in all contexts
+      result_array = lazy.to_a
+      expect(lazy.size).to eq(result_array.size)
+      expect(lazy.first).to eq(result_array.first)
+      expect(lazy.last).to eq(result_array.last)
+      expect(lazy.empty?).to eq(result_array.empty?)
+    end
+    
+    it 'supports array destructuring' do
+      a, b, c = lazy
+      expect(a).to eq("a")
+      expect(b).to eq("b")
+      expect(c).to eq("c")
+    end
+  end
+end