parsanol 3.0.0

data/spec/integration/result_builder_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+describe 'ResultBuilder Integration' do
+  include Parsanol
+  
+  let(:context) { Parsanol::Atoms::Context.new }
+
+  describe 'RepetitionBuilder infrastructure' do
+    it 'constructs repetition results using buffers' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 3)
+      builder.add_element('a')
+      builder.add_element('b')
+      builder.add_element('c')
+      result = builder.build
+      
+      # Should be a LazyResult
+      expect(result).to be_a(Parsanol::LazyResult)
+      expect(result.to_a).to eq([:repetition, 'a', 'b', 'c'])
+    end
+
+    it 'handles variable length results' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 2)
+      
+      # Add more than estimated
+      10.times { |i| builder.add_element(i) }
+      result = builder.build
+      
+      expect(result.size).to eq(11)  # tag + 10 elements
+      expect(result.to_a[0]).to eq(:repetition)
+      expect(result.to_a[10]).to eq(9)
+    end
+
+    it 'builds empty repetitions' do
+      builder = Parsanol::RepetitionBuilder.new(context)
+      result = builder.build
+      
+      expect(result.to_a).to eq([:repetition])
+    end
+
+    it 'supports custom tags' do
+      builder = Parsanol::RepetitionBuilder.new(context, tag: :my_list)
+      builder.add_element('x')
+      result = builder.build
+      
+      expect(result.to_a).to eq([:my_list, 'x'])
+    end
+  end
+
+  describe 'SequenceBuilder infrastructure' do
+    it 'constructs sequence results using buffers' do
+      builder = Parsanol::SequenceBuilder.new(context, size: 3)
+      builder.add_element('a')
+      builder.add_element('b')
+      builder.add_element('c')
+      result = builder.build
+      
+      expect(result).to be_a(Parsanol::LazyResult)
+      expect(result.to_a).to eq([:sequence, 'a', 'b', 'c'])
+    end
+
+    it 'filters nil values automatically' do
+      builder = Parsanol::SequenceBuilder.new(context, size: 4)
+      builder.add_element('a')
+      builder.add_element(nil)
+      builder.add_element('b')
+      builder.add_element(nil)
+      builder.add_element('c')
+      result = builder.build
+      
+      # Nils should be excluded
+      expect(result.to_a).to eq([:sequence, 'a', 'b', 'c'])
+    end
+
+    it 'handles empty sequences' do
+      builder = Parsanol::SequenceBuilder.new(context)
+      result = builder.build
+      
+      expect(result.to_a).to eq([:sequence])
+    end
+  end
+
+  describe 'HashBuilder infrastructure' do
+    it 'constructs hash directly without arrays' do
+      builder = Parsanol::HashBuilder.new(context)
+      builder.add_pair(:name, 'John')
+      builder.add_pair(:age, 30)
+      result = builder.build
+      
+      expect(result).to be_a(Hash)
+      expect(result).to eq({ name: 'John', age: 30 })
+    end
+
+    it 'handles complex values' do
+      builder = Parsanol::HashBuilder.new(context)
+      builder.add_pair(:array, ['a', 'b', 'c'])
+      builder.add_pair(:nested, { key: 'value' })
+      result = builder.build
+      
+      expect(result[:array]).to eq(['a', 'b', 'c'])
+      expect(result[:nested]).to eq({ key: 'value' })
+    end
+
+    it 'overwrites duplicate keys' do
+      builder = Parsanol::HashBuilder.new(context)
+      builder.add_pair(:key, 'old')
+      builder.add_pair(:key, 'new')
+      result = builder.build
+      
+      expect(result).to eq({ key: 'new' })
+    end
+  end
+
+  describe 'nested builder usage' do
+    it 'builds nested repetition-sequence structures' do
+      # Outer repetition
+      outer_builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 3)
+      
+      # Inner sequences
+      3.times do
+        inner_builder = Parsanol::SequenceBuilder.new(context, size: 2)
+        inner_builder.add_element('a')
+        inner_builder.add_element('b')
+        outer_builder.add_element(inner_builder.build)
+      end
+      
+      result = outer_builder.build
+      expect(result.size).to eq(4)  # tag + 3 sequences
+      expect(result[0]).to eq(:repetition)
+      
+      # Each element should be a sequence
+      result.to_a[1..3].each do |elem|
+        expect(elem).to be_a(Parsanol::LazyResult)
+        expect(elem.to_a).to eq([:sequence, 'a', 'b'])
+      end
+    end
+
+    it 'builds repetition with hash elements' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 2)
+      
+      hash_builder1 = Parsanol::HashBuilder.new(context)
+      hash_builder1.add_pair(:x, 1)
+      builder.add_element(hash_builder1.build)
+      
+      hash_builder2 = Parsanol::HashBuilder.new(context)
+      hash_builder2.add_pair(:x, 2)
+      builder.add_element(hash_builder2.build)
+      
+      result = builder.build
+      expect(result.to_a).to eq([:repetition, { x: 1 }, { x: 2 }])
+    end
+  end
+
+  describe 'buffer lifecycle management' do
+    it 'releases buffers properly' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 5)
+      builder.add_element('test')
+      
+      # Get buffer reference
+      buffer = builder.instance_variable_get(:@buffer)
+      expect(buffer).not_to be_nil
+      
+      # Release should clear reference
+      builder.release
+      expect(builder.instance_variable_get(:@buffer)).to be_nil
+    end
+
+    it 'buffers are reused from pool' do
+      # Create and release first builder
+      builder1 = Parsanol::RepetitionBuilder.new(context, estimated_size: 8)
+      builder1.add_element('a')
+      buffer1_capacity = builder1.instance_variable_get(:@buffer).capacity
+      builder1.release
+      
+      # Create second builder with same size
+      builder2 = Parsanol::RepetitionBuilder.new(context, estimated_size: 8)
+      buffer2_capacity = builder2.instance_variable_get(:@buffer).capacity
+      
+      # Should get buffer from same size class
+      expect(buffer2_capacity).to eq(buffer1_capacity)
+    end
+
+    it 'handles builder release on failure' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 3)
+      builder.add_element('test')
+      
+      # Simulate failure scenario - release should work
+      expect { builder.release }.not_to raise_error
+      
+      # Buffer should be cleared
+      expect(builder.instance_variable_get(:@buffer)).to be_nil
+    end
+  end
+
+  describe 'performance characteristics' do
+    it 'defers materialization with LazyResult' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 100)
+      100.times { |i| builder.add_element(i) }
+      result = builder.build
+      
+      # Result is lazy
+      expect(result).to be_a(Parsanol::LazyResult)
+      expect(result.instance_variable_get(:@materialized)).to be_nil
+      
+      # Accessing size doesn't materialize
+      expect(result.size).to eq(101)
+      expect(result.instance_variable_get(:@materialized)).to be_nil
+      
+      # Accessing array materializes
+      result.to_a
+      expect(result.instance_variable_get(:@materialized)).not_to be_nil
+    end
+
+    it 'handles large structures efficiently' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 1000)
+      
+      1000.times { |i| builder.add_element(i) }
+      result = builder.build
+      
+      expect(result.size).to eq(1001)
+      expect(result.to_a[0]).to eq(:repetition)
+      expect(result.to_a[-1]).to eq(999)
+    end
+
+    it 'caches materialized results' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 50)
+      50.times { |i| builder.add_element(i) }
+      result = builder.build
+      
+      # First materialization
+      array1 = result.to_a
+      
+      # Second call returns cached
+      array2 = result.to_a
+      expect(array2.object_id).to eq(array1.object_id)
+    end
+  end
+
+  describe 'factory method' do
+    it 'creates appropriate builder types' do
+      rep_builder = Parsanol::ResultBuilder.for(:repetition, context, estimated_size: 5)
+      expect(rep_builder).to be_a(Parsanol::RepetitionBuilder)
+      
+      seq_builder = Parsanol::ResultBuilder.for(:sequence, context, size: 3)
+      expect(seq_builder).to be_a(Parsanol::SequenceBuilder)
+      
+      hash_builder = Parsanol::ResultBuilder.for(:hash, context)
+      expect(hash_builder).to be_a(Parsanol::HashBuilder)
+    end
+
+    it 'passes options correctly' do
+      builder = Parsanol::ResultBuilder.for(:repetition, context, tag: :custom, estimated_size: 10)
+      expect(builder.instance_variable_get(:@tag)).to eq(:custom)
+    end
+  end
+
+  describe 'compatibility with LazyResult' do
+    it 'builders produce results compatible with existing code' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 3)
+      builder.add_element('a')
+      builder.add_element('b')
+      result = builder.build
+      
+      # Should work as array
+      expect(result.size).to eq(3)
+      expect(result[0]).to eq(:repetition)
+      expect(result.empty?).to be false
+      
+      # Should support enumerable
+      mapped = result.map { |x| x }
+      expect(mapped).to be_a(Array)
+    end
+
+    it 'results are comparable to arrays' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 2)
+      builder.add_element('x')
+      result = builder.build
+      
+      expect(result).to eq([:repetition, 'x'])
+      expect([:repetition, 'x']).to eq(result)
+    end
+  end
+end

data/spec/integration/rope_stringview_integration_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe 'Rope + StringView Integration' do
+  let(:source_str) { 'hello world this is a test' }
+  
+  describe 'Rope with StringView segments' do
+    it 'builds rope from StringView segments' do
+      rope = Parsanol::Rope.new
+      
+      # Create StringView segments (zero-copy)
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 5)
+      view2 = Parsanol::StringView.new(source_str, offset: 6, length: 5)
+      
+      rope.append(view1)
+      rope.append(' ')
+      rope.append(view2)
+      
+      expect(rope.to_s).to eq('hello world')
+    end
+    
+    it 'builds rope from mixed StringView and String segments' do
+      rope = Parsanol::Rope.new
+      
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 5)
+      
+      rope.append(view1)
+      rope.append(' from ')
+      rope.append('rope')
+      
+      expect(rope.to_s).to eq('hello from rope')
+    end
+    
+    it 'builds rope from Slices containing StringViews' do
+      rope = Parsanol::Rope.new
+      
+      # Create Slices with StringView (as Source.consume does)
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 5)
+      slice1 = Parsanol::Slice.new(0, view1)
+      
+      view2 = Parsanol::StringView.new(source_str, offset: 6, length: 5)
+      slice2 = Parsanol::Slice.new(6, view2)
+      
+      rope.append(slice1)
+      rope.append(' ')
+      rope.append(slice2)
+      
+      expect(rope.to_s).to eq('hello world')
+    end
+  end
+  
+  describe 'Slice.from_rope with StringView' do
+    it 'converts rope to slice' do
+      rope = Parsanol::Rope.new
+      rope.append('hello')
+      rope.append(' ')
+      rope.append('world')
+      
+      slice = Parsanol::Slice.from_rope(rope, 0)
+      
+      expect(slice.to_s).to eq('hello world')
+      expect(slice.offset).to eq(0)
+    end
+    
+    it 'converts rope with StringView segments to slice' do
+      rope = Parsanol::Rope.new
+      
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 5)
+      view2 = Parsanol::StringView.new(source_str, offset: 6, length: 5)
+      
+      rope.append(view1)
+      rope.append(' ')
+      rope.append(view2)
+      
+      slice = Parsanol::Slice.from_rope(rope, 0)
+      
+      expect(slice.to_s).to eq('hello world')
+      expect(slice.str).to eq('hello world')
+    end
+    
+    it 'preserves line cache when converting rope to slice' do
+      line_cache = double('line_cache')
+      allow(line_cache).to receive(:line_and_column).with(0).and_return([1, 1])
+      
+      rope = Parsanol::Rope.new.append('test')
+      slice = Parsanol::Slice.from_rope(rope, 0, line_cache)
+      
+      expect(slice.line_and_column).to eq([1, 1])
+    end
+  end
+  
+  describe 'Rope with UTF-8 StringView segments' do
+    let(:utf8_str) { 'Hello 世界 test' }
+    
+    it 'handles UTF-8 StringView segments correctly' do
+      rope = Parsanol::Rope.new
+      
+      # UTF-8 segment
+      view1 = Parsanol::StringView.new(utf8_str, offset: 0, length: 6)
+      view2 = Parsanol::StringView.new(utf8_str, offset: 6, length: 6)
+      
+      rope.append(view1)
+      rope.append(view2)
+      
+      result = rope.to_s
+      expect(result).to eq('Hello 世界')
+      expect(result.encoding).to eq(Encoding::UTF_8)
+    end
+    
+    it 'calculates size correctly for UTF-8 content' do
+      rope = Parsanol::Rope.new
+      
+      view1 = Parsanol::StringView.new(utf8_str, offset: 0, length: 6)
+      rope.append(view1)
+      
+      # Size based on string length, not byte length
+      expect(rope.size).to eq(6)
+    end
+  end
+  
+  describe 'Performance characteristics' do
+    it 'defers materialization until to_s called' do
+      rope = Parsanol::Rope.new
+      
+      # Create views (no string materialization yet)
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 5)
+      view2 = Parsanol::StringView.new(source_str, offset: 6, length: 5)
+      
+      rope.append(view1)
+      rope.append(view2)
+      
+      # Verify views haven't materialized yet
+      expect(view1.instance_variable_get(:@materialized)).to be_nil
+      expect(view2.instance_variable_get(:@materialized)).to be_nil
+      
+      # Materialize only on to_s
+      result = rope.to_s
+      
+      # Now views are materialized as part of joining
+      expect(result).to eq('helloworld')
+    end
+    
+    it 'handles large number of StringView segments efficiently' do
+      rope = Parsanol::Rope.new
+      
+      # Append 100 small segments
+      100.times do |i|
+        offset = i * 2
+        view = Parsanol::StringView.new('ab' * 100, offset: offset, length: 2)
+        rope.append(view)
+      end
+      
+      result = rope.to_s
+      expect(result.length).to eq(200)
+    end
+  end
+  
+  describe 'Edge cases' do
+    it 'handles empty StringView segments' do
+      rope = Parsanol::Rope.new
+      
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 0)
+      rope.append(view1)
+      rope.append('test')
+      
+      expect(rope.to_s).to eq('test')
+    end
+    
+    it 'handles rope with only StringView segments' do
+      rope = Parsanol::Rope.new
+      
+      view1 = Parsanol::StringView.new(source_str, offset: 0, length: 5)
+      view2 = Parsanol::StringView.new(source_str, offset: 6, length: 5)
+      view3 = Parsanol::StringView.new(source_str, offset: 12, length: 4)
+      
+      rope.append(view1).append(view2).append(view3)
+      
+      expect(rope.to_s).to eq('helloworldthis')
+    end
+    
+    it 'handles empty rope' do
+      rope = Parsanol::Rope.new
+      slice = Parsanol::Slice.from_rope(rope, 0)
+      
+      expect(slice.to_s).to eq('')
+      expect(slice.size).to eq(0)
+    end
+  end
+end

data/spec/integration/slice_pooling_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe "Slice Pooling Integration" do
+  it "source has a slice_pool" do
+    source = Parsanol::Source.new("hello world")
+    expect(source.slice_pool).to be_a(Parsanol::Pools::SlicePool)
+  end
+
+  it "source.consume uses pooled slices" do
+    source = Parsanol::Source.new("hello")
+    
+    # Consume should use the pool
+    slice1 = source.consume(1)
+    expect(slice1).to be_a(Parsanol::Slice)
+    expect(slice1.to_s).to eq("h")
+    
+    # Pool should show usage (created + reused)
+    stats = source.slice_pool.statistics
+    total_usage = stats[:created] + stats[:reused]
+    expect(total_usage).to be > 0
+  end
+
+  it "source.slice helper creates pooled slices" do
+    source = Parsanol::Source.new("test")
+    
+    slice = source.slice(0, "test")
+    expect(slice).to be_a(Parsanol::Slice)
+    expect(slice.to_s).to eq("test")
+    
+    stats = source.slice_pool.statistics
+    total_usage = stats[:created] + stats[:reused]
+    expect(total_usage).to be > 0
+  end
+
+  it "reuses slices during repetitive parsing" do
+    parser = Class.new(Parsanol::Parser) do
+      root :letters
+      rule(:letters) { str('a').repeat(10) }
+    end.new
+    
+    result = parser.parse("aaaaaaaaaa")
+    
+    # Verify the parser works with pooling
+    # The parse succeeded which means pooling worked
+    expect(result).to be_a(Parsanol::Slice)
+    expect(result.to_s).to eq("aaaaaaaaaa")
+  end
+  
+  it "handles complex parsing with pooling" do
+    parser = Class.new(Parsanol::Parser) do
+      root :expression
+      rule(:expression) {
+        (str('x') | str('y')).repeat(5) >>
+        str('!')
+      }
+    end.new
+    
+    result = parser.parse("xyxyx!")
+    # Result is flattened, so verify parse succeeded
+    expect(result).to be_a(Parsanol::Slice)
+    expect(result.to_s).to eq("xyxyx!")
+  end
+end

data/spec/integration/string_view_integration_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'StringView Integration' do
+  include Parsanol
+  
+  describe 'basic parsing with StringView' do
+    it 'parses simple string' do
+      parser = str('hello')
+      result = parser.parse('hello')
+      
+      expect(result).to be_a(Parsanol::Slice)
+      expect(result.to_s).to eq('hello')
+      expect(result.offset).to eq(0)
+    end
+    
+    it 'parses sequences' do
+      parser = str('a') >> str('b') >> str('c')
+      result = parser.parse('abc')
+      
+      # Sequences get flattened to a single slice by default
+      expect(result.to_s).to eq('abc')
+    end
+    
+    it 'parses alternatives' do
+      parser = str('hello') | str('world')
+      
+      result1 = parser.parse('hello')
+      expect(result1.to_s).to eq('hello')
+      
+      result2 = parser.parse('world')
+      expect(result2.to_s).to eq('world')
+    end
+    
+    it 'parses character classes' do
+      parser = match['a-z'].repeat(5, 5)
+      result = parser.parse('hello')
+      
+      # Repetitions with same min/max get flattened
+      expect(result.to_s).to eq('hello')
+    end
+    
+    it 'parses small repetitions' do
+      parser = str('a').repeat(3, 3)
+      result = parser.parse('aaa')
+      
+      # Repetitions with same min/max get flattened
+      expect(result.to_s).to eq('aaa')
+    end
+  end
+  
+  describe 'backward compatibility' do
+    it 'Slice#str materializes string from StringView' do
+      parser = str('test')
+      result = parser.parse('test')
+      
+      expect(result.str).to eq('test')
+      expect(result.str).to be_a(String)
+    end
+    
+    it 'Slice#to_s works with StringView' do
+      parser = str('test')
+      result = parser.parse('test')
+      
+      expect(result.to_s).to eq('test')
+    end
+    
+    it 'Slice comparison works with StringView' do
+      parser = str('test')
+      result = parser.parse('test')
+      
+      expect(result).to eq('test')
+      expect(result == 'test').to be true
+    end
+    
+    it 'Slice concatenation works with StringView' do
+      parser = str('a').as(:a) >> str('b').as(:b)
+      result = parser.parse('ab')
+      
+      # Access via hash keys
+      concatenated = result[:a] + result[:b]
+      expect(concatenated.to_s).to eq('ab')
+    end
+  end
+  
+  describe 'UTF-8 support' do
+    it 'handles UTF-8 strings correctly' do
+      parser = str('世界')
+      result = parser.parse('世界')
+      
+      expect(result.to_s).to eq('世界')
+    end
+    
+    it 'handles mixed ASCII and UTF-8' do
+      parser = str('hello').as(:en) >> str('世界').as(:jp)
+      result = parser.parse('hello世界')
+      
+      expect(result[:en].to_s).to eq('hello')
+      expect(result[:jp].to_s).to eq('世界')
+    end
+  end
+  
+  describe 'memory efficiency' do
+    it 'caches materialized strings' do
+      parser = str('test')
+      result = parser.parse('test')
+      
+      # Calling str multiple times should return same object
+      str1 = result.str
+      str2 = result.str
+      expect(str1.object_id).to eq(str2.object_id)
+    end
+  end
+  
+  describe 'line and column tracking' do
+    it 'tracks position correctly' do
+      parser = str('hello')
+      result = parser.parse('hello')
+      
+      expect(result.line_and_column).to eq([1, 1])
+      expect(result.offset).to eq(0)
+    end
+  end
+end