parsanol 3.0.0

data/spec/integration/array_pooling_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+require 'parsanol/parslet'
+
+# Integration tests for Phase 1.3: Array Buffer Pooling
+# Verifies that ArrayPool is properly integrated into Context and used by atoms
+describe "Array Pooling Integration" do
+  describe "Context integration" do
+    it "has an array_pool" do
+      context = Parsanol::Atoms::Context.new
+      expect(context.array_pool).to be_a(Parsanol::Pools::ArrayPool)
+    end
+
+    it "provides acquire_array helper" do
+      context = Parsanol::Atoms::Context.new
+      array = context.acquire_array
+      expect(array).to be_a(Array)
+      expect(array).to be_empty
+    end
+
+    it "provides release_array helper" do
+      context = Parsanol::Atoms::Context.new
+      array = context.acquire_array
+      array << 1 << 2 << 3
+      result = context.release_array(array)
+      expect(result).to be true
+    end
+
+    it "clears arrays on release" do
+      context = Parsanol::Atoms::Context.new
+      array = context.acquire_array
+      array << 1 << 2 << 3
+      context.release_array(array)
+      
+      # Next acquisition should get a cleared array
+      array2 = context.acquire_array
+      expect(array2).to be_empty
+    end
+  end
+
+  describe "Repetition parsing with array pooling" do
+    it "reuses arrays during simple repetition" do
+      parser = Class.new(Parsanol::Parser) do
+        root :items
+        rule(:items) { str('x').repeat(5) }
+      end.new
+      
+      result = parser.parse("xxxxx")
+      expect(result.to_s).to eq("xxxxx")
+    end
+
+    it "reuses arrays during repetition with min/max" do
+      parser = Class.new(Parsanol::Parser) do
+        root :items
+        rule(:items) { str('a').repeat(2, 4) }
+      end.new
+      
+      result = parser.parse("aaa")
+      expect(result.to_s).to eq("aaa")
+    end
+
+    it "handles nested repetitions with pooling" do
+      parser = Class.new(Parsanol::Parser) do
+        root :nested
+        rule(:nested) { (str('x') >> str('x')).repeat(3) }
+      end.new
+      
+      result = parser.parse("xxxxxx")
+      expect(result.to_s).to eq("xxxxxx")
+    end
+
+    it "handles maybe (repeat(0,1)) with pooling" do
+      parser = Class.new(Parsanol::Parser) do
+        root :optional
+        rule(:optional) { str('a').maybe >> str('b') }
+      end.new
+      
+      expect(parser.parse("b").to_s).to eq("b")
+      expect(parser.parse("ab").to_s).to eq("ab")
+    end
+  end
+
+  describe "Sequence parsing with array pooling" do
+    it "reuses arrays during simple sequence" do
+      parser = Class.new(Parsanol::Parser) do
+        root :sequence
+        rule(:sequence) { str('a') >> str('b') >> str('c') }
+      end.new
+      
+      result = parser.parse("abc")
+      expect(result.to_s).to eq("abc")
+    end
+
+    it "reuses arrays during longer sequences" do
+      parser = Class.new(Parsanol::Parser) do
+        root :sequence
+        rule(:sequence) { str('a') >> str('b') >> str('c') >> str('d') >> str('e') }
+      end.new
+      
+      result = parser.parse("abcde")
+      expect(result.to_s).to eq("abcde")
+    end
+
+    it "handles nested sequences with pooling" do
+      parser = Class.new(Parsanol::Parser) do
+        root :nested
+        rule(:nested) { (str('a') >> str('b')) >> (str('c') >> str('d')) }
+      end.new
+      
+      result = parser.parse("abcd")
+      expect(result.to_s).to eq("abcd")
+    end
+  end
+
+  describe "Complex parsing with array pooling" do
+    it "handles mixed repetitions and sequences" do
+      parser = Class.new(Parsanol::Parser) do
+        root :mixed
+        rule(:mixed) { (str('x') >> str('y')).repeat(3) }
+      end.new
+      
+      result = parser.parse("xyxyxy")
+      expect(result.to_s).to eq("xyxyxy")
+    end
+
+    it "handles repetition of sequences" do
+      parser = Class.new(Parsanol::Parser) do
+        root :items
+        rule(:items) { item.repeat(3) }
+        rule(:item) { str('a') >> str('b') >> space? }
+        rule(:space?) { str(' ').maybe }
+      end.new
+      
+      result = parser.parse("ab ab ab")
+      expect(result.to_s).to eq("ab ab ab")
+    end
+  end
+
+  describe "Array pool statistics" do
+    it "shows pool reuse during parsing" do
+      # Create a context and verify pool behavior
+      context = Parsanol::Atoms::Context.new
+      pool = context.array_pool
+      
+      # ArrayPool is preallocated, so we need to exhaust the pool first
+      # to see newly created arrays. For this test, just verify the pool exists
+      # and can acquire/release arrays correctly.
+      
+      # Acquire an array
+      arr1 = context.acquire_array
+      expect(arr1).to be_a(Array)
+      expect(arr1).to be_empty
+      
+      # Release it back
+      arr1 << 1 << 2 << 3
+      result = context.release_array(arr1)
+      expect(result).to be true
+      
+      # Acquire again - should get a cleared array
+      arr2 = context.acquire_array
+      expect(arr2).to be_empty
+      
+      # Verify pool statistics exist
+      stats = pool.statistics
+      expect(stats).to have_key(:created)
+      expect(stats).to have_key(:reused)
+      expect(stats).to have_key(:size)
+      expect(stats).to have_key(:utilization)
+    end
+  end
+  
+  describe "Array structure preservation" do
+    it "maintains [:repetition, ...] structure" do
+      parser = Class.new(Parsanol::Parser) do
+        root :items
+        rule(:items) { str('x').repeat(3) }
+      end.new
+      
+      result = parser.parse("xxx")
+      # Result should be a Parsanol::Slice or properly tagged array
+      expect(result.to_s).to eq("xxx")
+    end
+    
+    it "maintains [:sequence, ...] structure" do
+      parser = Class.new(Parsanol::Parser) do
+        root :seq
+        rule(:seq) { str('a') >> str('b') }
+      end.new
+      
+      result = parser.parse("ab")
+      expect(result.to_s).to eq("ab")
+    end
+  end
+end

data/spec/integration/buffer_allocation_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+require 'parsanol/parslet'
+
+# Integration tests for Phase 2.1: Fixed-Size Buffer Pre-allocation
+# Verifies that BufferPool is properly integrated into Context and accessible
+describe "Buffer Allocation Integration" do
+  describe "Context integration" do
+    it "has a buffer_pool" do
+      context = Parsanol::Atoms::Context.new
+      expect(context.buffer_pool).to be_a(Parsanol::Pools::BufferPool)
+    end
+
+    it "provides acquire_buffer helper" do
+      context = Parsanol::Atoms::Context.new
+      buffer = context.acquire_buffer(size: 8)
+      
+      expect(buffer).to be_a(Parsanol::Buffer)
+      expect(buffer.capacity).to be >= 8
+      expect(buffer).to be_empty
+    end
+
+    it "provides release_buffer helper" do
+      context = Parsanol::Atoms::Context.new
+      buffer = context.acquire_buffer(size: 8)
+      buffer.push("a")
+      buffer.push("b")
+      
+      result = context.release_buffer(buffer)
+      expect(result).to be true
+    end
+
+    it "clears buffers on release" do
+      context = Parsanol::Atoms::Context.new
+      
+      # Acquire and use buffer
+      buffer = context.acquire_buffer(size: 4)
+      buffer.push("a")
+      buffer.push("b")
+      buffer.push("c")
+      context.release_buffer(buffer)
+      
+      # Next acquisition should get a cleared buffer
+      buffer2 = context.acquire_buffer(size: 4)
+      expect(buffer2).to be_empty
+      expect(buffer2.size).to eq(0)
+    end
+
+    it "reuses buffers across acquire/release cycles" do
+      context = Parsanol::Atoms::Context.new
+      
+      # First cycle
+      buffer1 = context.acquire_buffer(size: 8)
+      buffer1_id = buffer1.object_id
+      context.release_buffer(buffer1)
+      
+      # Second cycle - should reuse same buffer
+      buffer2 = context.acquire_buffer(size: 8)
+      expect(buffer2.object_id).to eq(buffer1_id)
+    end
+  end
+
+  describe "Buffer size class selection" do
+    let(:context) { Parsanol::Atoms::Context.new }
+
+    it "selects appropriate size classes" do
+      test_cases = [
+        [2, 2],
+        [3, 4],
+        [5, 8],
+        [10, 16],
+        [20, 32],
+        [50, 64]
+      ]
+
+      test_cases.each do |requested, expected|
+        buffer = context.acquire_buffer(size: requested)
+        expect(buffer.capacity).to eq(expected),
+          "size #{requested} should get capacity #{expected}, got #{buffer.capacity}"
+        context.release_buffer(buffer)
+      end
+    end
+
+    it "handles standard size classes" do
+      Parsanol::Pools::BufferPool::SIZE_CLASSES.each do |size|
+        buffer = context.acquire_buffer(size: size)
+        expect(buffer.capacity).to eq(size)
+        context.release_buffer(buffer)
+      end
+    end
+  end
+
+  describe "Buffer pool statistics" do
+    it "tracks buffer creation and reuse" do
+      context = Parsanol::Atoms::Context.new
+      pool = context.buffer_pool
+      
+      # First acquire - creates new buffer
+      buffer1 = context.acquire_buffer(size: 8)
+      context.release_buffer(buffer1)
+      
+      # Second acquire - reuses buffer
+      buffer2 = context.acquire_buffer(size: 8)
+      context.release_buffer(buffer2)
+      
+      # Check statistics
+      stats = pool.statistics
+      expect(stats).to be_a(Hash)
+      expect(stats[8]).to include(
+        :created,
+        :reused,
+        :released,
+        :utilization
+      )
+      
+      expect(stats[8][:created]).to eq(1)
+      expect(stats[8][:reused]).to eq(1)
+      expect(stats[8][:utilization]).to be > 0
+    end
+
+    it "tracks statistics per size class" do
+      context = Parsanol::Atoms::Context.new
+      pool = context.buffer_pool
+      
+      # Use different size classes
+      buffer2 = context.acquire_buffer(size: 2)
+      buffer4 = context.acquire_buffer(size: 4)
+      buffer8 = context.acquire_buffer(size: 8)
+      
+      context.release_buffer(buffer2)
+      context.release_buffer(buffer4)
+      context.release_buffer(buffer8)
+      
+      stats = pool.statistics
+      expect(stats[2][:created]).to eq(1)
+      expect(stats[4][:created]).to eq(1)
+      expect(stats[8][:created]).to eq(1)
+    end
+  end
+
+  describe "Buffer lifecycle" do
+    it "maintains buffer capacity across reuse" do
+      context = Parsanol::Atoms::Context.new
+      
+      # Create buffer with capacity 8
+      buffer = context.acquire_buffer(size: 8)
+      expect(buffer.capacity).to eq(8)
+      
+      # Fill it
+      8.times { |i| buffer.push(i) }
+      expect(buffer.size).to eq(8)
+      
+      # Release and reacquire
+      context.release_buffer(buffer)
+      buffer2 = context.acquire_buffer(size: 8)
+      
+      # Capacity should be preserved, size reset
+      expect(buffer2.capacity).to eq(8)
+      expect(buffer2.size).to eq(0)
+    end
+
+    it "handles buffer growth gracefully" do
+      context = Parsanol::Atoms::Context.new
+      
+      # Acquire small buffer
+      buffer = context.acquire_buffer(size: 4)
+      expect(buffer.capacity).to eq(4)
+      
+      # Grow beyond capacity
+      10.times { |i| buffer.push(i) }
+      expect(buffer.size).to eq(10)
+      expect(buffer.capacity).to be > 4
+      
+      # Verify contents
+      expect(buffer.to_a).to eq((0..9).to_a)
+    end
+  end
+
+  describe "Multiple contexts" do
+    it "each context has independent buffer pool" do
+      context1 = Parsanol::Atoms::Context.new
+      context2 = Parsanol::Atoms::Context.new
+      
+      pool1 = context1.buffer_pool
+      pool2 = context2.buffer_pool
+      
+      expect(pool1.object_id).not_to eq(pool2.object_id)
+      
+      # Activity in one doesn't affect the other
+      buffer1 = context1.acquire_buffer(size: 8)
+      context1.release_buffer(buffer1)
+      
+      stats1 = pool1.statistics[8]
+      stats2 = pool2.statistics[8]
+      
+      expect(stats1[:created]).to eq(1)
+      expect(stats2[:created]).to eq(0)
+    end
+  end
+
+  describe "Buffer operations" do
+    let(:context) { Parsanol::Atoms::Context.new }
+
+    it "supports push operations" do
+      buffer = context.acquire_buffer(size: 4)
+      
+      buffer.push("a")
+      buffer.push("b")
+      
+      expect(buffer.size).to eq(2)
+      expect(buffer.to_a).to eq(["a", "b"])
+      
+      context.release_buffer(buffer)
+    end
+
+    it "supports array conversion" do
+      buffer = context.acquire_buffer(size: 8)
+      
+      elements = ["x", "y", "z"]
+      elements.each { |e| buffer.push(e) }
+      
+      result = buffer.to_a
+      expect(result).to eq(elements)
+      expect(result).to be_a(Array)
+      
+      context.release_buffer(buffer)
+    end
+
+    it "supports indexing" do
+      buffer = context.acquire_buffer(size: 8)
+      
+      buffer.push("a")
+      buffer.push("b")
+      buffer.push("c")
+      
+      expect(buffer[0]).to eq("a")
+      expect(buffer[1]).to eq("b")
+      expect(buffer[2]).to eq("c")
+      
+      buffer[1] = "x"
+      expect(buffer[1]).to eq("x")
+      
+      context.release_buffer(buffer)
+    end
+
+    it "supports empty? check" do
+      buffer = context.acquire_buffer(size: 4)
+      
+      expect(buffer.empty?).to be true
+      
+      buffer.push("a")
+      expect(buffer.empty?).to be false
+      
+      buffer.clear!
+      expect(buffer.empty?).to be true
+      
+      context.release_buffer(buffer)
+    end
+  end
+
+  describe "Pool capacity management" do
+    it "handles pool overflow gracefully" do
+      context = Parsanol::Atoms::Context.new
+      pool = context.buffer_pool
+      
+      # Note: BufferPool has pool_size of 100 by default
+      # We'll just verify the pool can handle multiple buffer cycles
+      
+      10.times do
+        buffer = context.acquire_buffer(size: 8)
+        buffer.push("data")
+        context.release_buffer(buffer)
+      end
+      
+      stats = pool.statistics[8]
+      expect(stats[:released]).to be >= 10
+    end
+  end
+
+  describe "Performance characteristics" do
+    it "buffer reuse reduces allocations" do
+      context = Parsanol::Atoms::Context.new
+      pool = context.buffer_pool
+      
+      # Clear statistics
+      pool.clear!
+      
+      # Perform multiple acquire/release cycles
+      cycles = 20
+      cycles.times do
+        buffer = context.acquire_buffer(size: 8)
+        buffer.push("x")
+        context.release_buffer(buffer)
+      end
+      
+      stats = pool.statistics[8]
+      
+      # Should have high reuse rate
+      # First acquire creates, rest reuse
+      expect(stats[:created]).to be <= 2
+      expect(stats[:reused]).to be >= (cycles - 2)
+      expect(stats[:utilization]).to be > 80.0
+    end
+  end
+
+  describe "Context pool coexistence" do
+    it "buffer_pool works alongside array_pool" do
+      context = Parsanol::Atoms::Context.new
+      
+      # Both pools should exist
+      expect(context.array_pool).to be_a(Parsanol::Pools::ArrayPool)
+      expect(context.buffer_pool).to be_a(Parsanol::Pools::BufferPool)
+      
+      # Both should be functional
+      array = context.acquire_array
+      buffer = context.acquire_buffer(size: 4)
+      
+      expect(array).to be_a(Array)
+      expect(buffer).to be_a(Parsanol::Buffer)
+      
+      context.release_array(array)
+      context.release_buffer(buffer)
+    end
+  end
+end

data/spec/integration/position_pooling_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'parsanol/parslet'
+
+describe "Position Pooling Integration" do
+  describe "Source integration" do
+    let(:source) { Parsanol::Source.new("hello\nworld\n") }
+    
+    it "has a position_pool" do
+      expect(source.position_pool).to be_a(Parsanol::Pools::PositionPool)
+    end
+
+    it "creates pooled positions" do
+      pos1 = source.position(0)
+      expect(pos1).to be_a(Parsanol::Position)
+      expect(pos1.bytepos).to eq(0)
+    end
+
+    it "position method works without arguments" do
+      source.bytepos = 5
+      pos = source.position
+      expect(pos.bytepos).to eq(5)
+    end
+
+    it "positions can be reused from pool" do
+      pos1 = source.position(0)
+      id1 = pos1.object_id
+      
+      # Release back to pool (simulated by creating another position)
+      source.position_pool.release(pos1)
+      
+      # Get another position - should reuse the same object
+      pos2 = source.position(10)
+      expect(pos2.object_id).to eq(id1)
+      expect(pos2.bytepos).to eq(10)
+    end
+  end
+
+  describe "Error reporting with pooled positions" do
+    def catch_failed_parse
+      yield
+      nil
+    rescue Parsanol::ParseFailed => e
+      e
+    end
+
+    it "generates error messages correctly" do
+      parser = Class.new(Parsanol::Parser) do
+        root :num
+        rule(:num) { match('[0-9]').repeat(1) }
+      end.new
+      
+      error = catch_failed_parse { parser.parse("abc") }
+      expect(error).to be_a(Parsanol::ParseFailed)
+      expect(error.message).to include("line 1")
+    end
+
+    it "handles multi-line input with correct line numbers" do
+      parser = Class.new(Parsanol::Parser) do
+        root :lines
+        rule(:lines) { line.repeat }
+        rule(:line) { match('[0-9]').repeat(1) >> str("\n") }
+      end.new
+      
+      error = catch_failed_parse { parser.parse("123\n456\nabc\n") }
+      expect(error).to be_a(Parsanol::ParseFailed)
+      expect(error.message).to include("line 3")
+    end
+  end
+
+  describe "Pool statistics and reuse" do
+    it "shows position reuse in pool statistics" do
+      source = Parsanol::Source.new("test input for pooling")
+      pool = source.position_pool
+      
+      # Create multiple positions
+      pos1 = source.position(0)
+      pos2 = source.position(5)
+      pos3 = source.position(10)
+      
+      # Check that positions were created
+      stats = pool.statistics
+      expect(stats[:created]).to be >= 3
+      
+      # Release and reuse
+      pool.release(pos1)
+      pool.release(pos2)
+      pool.release(pos3)
+      
+      pos4 = source.position(15)
+      pos5 = source.position(20)
+      
+      # Should show reuse
+      stats = pool.statistics
+      expect(stats[:reused]).to be >= 2
+      expect(stats[:utilization]).to be > 0
+    end
+
+    it "pool handles many position creations efficiently" do
+      source = Parsanol::Source.new("a" * 1000)
+      pool = source.position_pool
+      
+      # Create many positions
+      100.times do |i|
+        pos = source.position(i)
+        pool.release(pos) if i % 2 == 0  # Release half of them
+      end
+      
+      stats = pool.statistics
+      # Verify pool is being used
+      expect(stats[:created]).to be > 0
+      expect(stats[:released]).to be > 0
+      
+      # Check that utilization is reasonable
+      # We release 50 and create 50 more in the next phase
+      expect(stats[:utilization]).to be >= 0
+    end
+  end
+
+  describe "Position object correctness" do
+    it "positions maintain correct byte and character positions" do
+      # Test with ASCII
+      source = Parsanol::Source.new("hello world")
+      pos = source.position(6)
+      
+      expect(pos.bytepos).to eq(6)
+      expect(pos.charpos).to eq(6)  # ASCII: byte == char
+    end
+
+    it "positions work with UTF-8 strings" do
+      # Test with UTF-8
+      source = Parsanol::Source.new("café")
+      pos = source.position(4)  # After 'caf'
+      
+      expect(pos.bytepos).to eq(4)
+      # charpos calculation may differ based on encoding
+      expect(pos.charpos).to be_a(Integer)
+    end
+
+    it "positions track source string correctly" do
+      input = "test string"
+      source = Parsanol::Source.new(input)
+      pos = source.position(5)
+      
+      # Position should reference the original source string
+      expect(pos.string).to eq(input)
+    end
+  end
+
+  describe "Integration with existing parser" do
+    class SimpleParser < Parsanol::Parser
+      root :document
+      rule(:document) { word.repeat.as(:words) }
+      rule(:word) { match('[a-z]').repeat(1).as(:word) >> space.maybe }
+      rule(:space) { match('\s').repeat(1) }
+    end
+
+    it "parser works correctly with position pooling" do
+      parser = SimpleParser.new
+      result = parser.parse("hello world")
+      
+      expect(result).to eq({
+        words: [
+          { word: "hello" },
+          { word: "world" }
+        ]
+      })
+    end
+
+    it "parser generates errors with position information" do
+      parser = SimpleParser.new
+      
+      error = begin
+        parser.parse("hello 123")
+      rescue Parsanol::ParseFailed => e
+        e
+      end
+      
+      expect(error).to be_a(Parsanol::ParseFailed)
+      expect(error.message).to match(/line \d+ char \d+/)
+    end
+  end
+end