parsanol 3.0.0

data/spec/parsanol/result_builder_spec.rb

@@ -0,0 +1,391 @@
+require 'spec_helper'
+
+describe Parsanol::ResultBuilder do
+  let(:context) { Parsanol::Atoms::Context.new }
+
+  describe '.for' do
+    it 'creates RepetitionBuilder for :repetition' do
+      builder = described_class.for(:repetition, context)
+      expect(builder).to be_a(Parsanol::RepetitionBuilder)
+    end
+    
+    it 'creates SequenceBuilder for :sequence' do
+      builder = described_class.for(:sequence, context)
+      expect(builder).to be_a(Parsanol::SequenceBuilder)
+    end
+    
+    it 'creates HashBuilder for :hash' do
+      builder = described_class.for(:hash, context)
+      expect(builder).to be_a(Parsanol::HashBuilder)
+    end
+    
+    it 'raises error for unknown type' do
+      expect { described_class.for(:unknown, context) }.to raise_error(ArgumentError, /Unknown builder type/)
+    end
+
+    it 'passes options to builder' do
+      builder = described_class.for(:repetition, context, tag: :custom, estimated_size: 20)
+      expect(builder.instance_variable_get(:@tag)).to eq(:custom)
+    end
+  end
+
+  describe Parsanol::RepetitionBuilder do
+    let(:builder) { described_class.new(context, estimated_size: 5) }
+
+    describe '#initialize' do
+      it 'acquires buffer from context' do
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer).to be_a(Parsanol::Buffer)
+      end
+
+      it 'pushes default tag to buffer' do
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer[0]).to eq(:repetition)
+      end
+
+      it 'supports custom tags' do
+        custom_builder = described_class.new(context, tag: :custom)
+        buffer = custom_builder.instance_variable_get(:@buffer)
+        expect(buffer[0]).to eq(:custom)
+      end
+
+      it 'uses estimated_size for buffer allocation' do
+        # Buffer should be acquired with capacity for tag + elements
+        expect(context.buffer_pool).to receive(:acquire).with(size: 6).and_call_original
+        described_class.new(context, estimated_size: 5)
+      end
+    end
+
+    describe '#add_element' do
+      it 'adds element to buffer' do
+        builder.add_element("a")
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer[1]).to eq("a")
+      end
+
+      it 'adds multiple elements' do
+        builder.add_element("a")
+        builder.add_element("b")
+        builder.add_element("c")
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer.size).to eq(4)  # tag + 3 elements
+        expect(buffer[1]).to eq("a")
+        expect(buffer[2]).to eq("b")
+        expect(buffer[3]).to eq("c")
+      end
+
+      it 'returns self for chaining' do
+        result = builder.add_element("a")
+        expect(result).to eq(builder)
+      end
+
+      it 'can chain multiple adds' do
+        builder.add_element("a").add_element("b").add_element("c")
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer.size).to eq(4)
+      end
+    end
+
+    describe '#build' do
+      it 'returns LazyResult' do
+        builder.add_element("a")
+        builder.add_element("b")
+        result = builder.build
+        
+        expect(result).to be_a(Parsanol::LazyResult)
+      end
+
+      it 'constructs repetition with tag' do
+        builder.add_element("a")
+        builder.add_element("b")
+        result = builder.build
+        
+        expect(result.to_a).to eq([:repetition, "a", "b"])
+      end
+
+      it 'handles empty repetition' do
+        result = builder.build
+        expect(result.to_a).to eq([:repetition])
+      end
+
+      it 'uses custom tags' do
+        custom_builder = described_class.new(context, tag: :custom, estimated_size: 3)
+        custom_builder.add_element("x")
+        result = custom_builder.build
+        
+        expect(result.to_a).to eq([:custom, "x"])
+      end
+
+      it 'handles large repetitions' do
+        100.times { |i| builder.add_element(i) }
+        result = builder.build
+        
+        expect(result.size).to eq(101)  # tag + 100 elements
+        expect(result[0]).to eq(:repetition)
+        expect(result[100]).to eq(99)
+      end
+    end
+
+    describe '#release' do
+      it 'releases buffer back to pool' do
+        builder.add_element("test")
+        buffer = builder.instance_variable_get(:@buffer)
+        
+        expect(context.buffer_pool).to receive(:release).with(buffer).and_call_original
+        builder.release
+      end
+
+      it 'clears buffer reference' do
+        builder.add_element("test")
+        builder.release
+        
+        expect(builder.instance_variable_get(:@buffer)).to be_nil
+      end
+
+      it 'handles double release safely' do
+        builder.release
+        expect { builder.release }.not_to raise_error
+      end
+    end
+  end
+
+  describe Parsanol::SequenceBuilder do
+    let(:builder) { described_class.new(context, size: 3) }
+
+    describe '#initialize' do
+      it 'acquires buffer from context' do
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer).to be_a(Parsanol::Buffer)
+      end
+
+      it 'pushes :sequence tag to buffer' do
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer[0]).to eq(:sequence)
+      end
+
+      it 'uses size for buffer allocation' do
+        expect(context.buffer_pool).to receive(:acquire).with(size: 4).and_call_original
+        described_class.new(context, size: 3)
+      end
+    end
+
+    describe '#add_element' do
+      it 'adds element to buffer' do
+        builder.add_element("a")
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer[1]).to eq("a")
+      end
+
+      it 'adds multiple elements' do
+        builder.add_element("a")
+        builder.add_element("b")
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer.size).to eq(3)  # tag + 2 elements
+        expect(buffer[1]).to eq("a")
+        expect(buffer[2]).to eq("b")
+      end
+
+      it 'skips nil values' do
+        builder.add_element("a")
+        builder.add_element(nil)
+        builder.add_element("b")
+        buffer = builder.instance_variable_get(:@buffer)
+        expect(buffer.size).to eq(3)  # tag + 2 non-nil elements
+        expect(buffer[1]).to eq("a")
+        expect(buffer[2]).to eq("b")
+      end
+
+      it 'returns self for chaining' do
+        result = builder.add_element("a")
+        expect(result).to eq(builder)
+      end
+    end
+
+    describe '#build' do
+      it 'returns LazyResult' do
+        builder.add_element("a")
+        result = builder.build
+        
+        expect(result).to be_a(Parsanol::LazyResult)
+      end
+
+      it 'constructs sequence with tag' do
+        builder.add_element("a")
+        builder.add_element("b")
+        result = builder.build
+        
+        expect(result.to_a).to eq([:sequence, "a", "b"])
+      end
+
+      it 'handles empty sequence' do
+        result = builder.build
+        expect(result.to_a).to eq([:sequence])
+      end
+
+      it 'excludes nil values from result' do
+        builder.add_element("a")
+        builder.add_element(nil)
+        builder.add_element("b")
+        result = builder.build
+        
+        expect(result.to_a).to eq([:sequence, "a", "b"])
+      end
+    end
+
+    describe '#release' do
+      it 'releases buffer back to pool' do
+        builder.add_element("test")
+        buffer = builder.instance_variable_get(:@buffer)
+        
+        expect(context.buffer_pool).to receive(:release).with(buffer).and_call_original
+        builder.release
+      end
+
+      it 'clears buffer reference' do
+        builder.add_element("test")
+        builder.release
+        
+        expect(builder.instance_variable_get(:@buffer)).to be_nil
+      end
+    end
+  end
+
+  describe Parsanol::HashBuilder do
+    let(:builder) { described_class.new(context) }
+
+    describe '#initialize' do
+      it 'initializes empty hash' do
+        hash = builder.instance_variable_get(:@hash)
+        expect(hash).to eq({})
+      end
+    end
+
+    describe '#add_pair' do
+      it 'adds key-value pair' do
+        builder.add_pair(:key1, "value1")
+        hash = builder.instance_variable_get(:@hash)
+        expect(hash).to eq({ key1: "value1" })
+      end
+
+      it 'adds multiple pairs' do
+        builder.add_pair(:key1, "value1")
+        builder.add_pair(:key2, "value2")
+        hash = builder.instance_variable_get(:@hash)
+        expect(hash).to eq({ key1: "value1", key2: "value2" })
+      end
+
+      it 'returns self for chaining' do
+        result = builder.add_pair(:key, "value")
+        expect(result).to eq(builder)
+      end
+
+      it 'can chain multiple adds' do
+        builder.add_pair(:a, 1).add_pair(:b, 2).add_pair(:c, 3)
+        hash = builder.instance_variable_get(:@hash)
+        expect(hash).to eq({ a: 1, b: 2, c: 3 })
+      end
+
+      it 'overwrites existing keys' do
+        builder.add_pair(:key, "old")
+        builder.add_pair(:key, "new")
+        hash = builder.instance_variable_get(:@hash)
+        expect(hash).to eq({ key: "new" })
+      end
+    end
+
+    describe '#build' do
+      it 'returns hash directly' do
+        builder.add_pair(:key1, "value1")
+        builder.add_pair(:key2, "value2")
+        result = builder.build
+        
+        expect(result).to be_a(Hash)
+        expect(result).to eq({ key1: "value1", key2: "value2" })
+      end
+
+      it 'handles empty hash' do
+        result = builder.build
+        expect(result).to eq({})
+      end
+
+      it 'supports complex values' do
+        builder.add_pair(:array, ["a", "b"])
+        builder.add_pair(:hash, { nested: true })
+        builder.add_pair(:number, 42)
+        result = builder.build
+        
+        expect(result).to eq({
+          array: ["a", "b"],
+          hash: { nested: true },
+          number: 42
+        })
+      end
+    end
+
+    describe '#release' do
+      it 'clears hash reference' do
+        builder.add_pair(:test, "value")
+        builder.release
+        
+        expect(builder.instance_variable_get(:@hash)).to be_nil
+      end
+
+      it 'handles double release safely' do
+        builder.release
+        expect { builder.release }.not_to raise_error
+      end
+    end
+  end
+
+  describe 'integration with Context' do
+    it 'builders use context buffer pool' do
+      repetition_builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 5)
+      sequence_builder = Parsanol::SequenceBuilder.new(context, size: 3)
+      
+      # Both should acquire from same pool
+      stats = context.buffer_pool.statistics
+      # Statistics should have size class keys (2, 4, 8, etc.)
+      expect(stats.keys).to include(8)  # Size 8 is standard size class
+    end
+
+    it 'releases return buffers to pool' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 5)
+      builder.add_element("test")
+      
+      stats_before = context.buffer_pool.statistics
+      builder.release
+      stats_after = context.buffer_pool.statistics
+      
+      # Buffer should be released (stats should reflect this)
+      expect(stats_after).to be_a(Hash)
+    end
+  end
+
+  describe 'memory efficiency' do
+    it 'reuses buffers across multiple builders' do
+      # Create and release first builder
+      builder1 = Parsanol::RepetitionBuilder.new(context, estimated_size: 5)
+      builder1.add_element("a")
+      buffer1 = builder1.instance_variable_get(:@buffer)
+      builder1.release
+      
+      # Create second builder - should reuse buffer
+      builder2 = Parsanol::RepetitionBuilder.new(context, estimated_size: 5)
+      buffer2 = builder2.instance_variable_get(:@buffer)
+      
+      # Buffers come from same size class, demonstrating reuse
+      expect(buffer1.capacity).to eq(buffer2.capacity)
+    end
+
+    it 'builders handle growth when capacity exceeded' do
+      builder = Parsanol::RepetitionBuilder.new(context, estimated_size: 2)
+      
+      # Add more elements than initial capacity
+      10.times { |i| builder.add_element(i) }
+      
+      result = builder.build
+      expect(result.size).to eq(11)  # tag + 10 elements
+      expect(result.to_a).to eq([:repetition, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    end
+  end
+end

data/spec/parsanol/rig/rspec_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'parsanol/rig/rspec'
+
+describe 'rspec integration' do
+  include Parsanol
+  subject { str('example') }
+
+  it { should parse('example') }
+  it { should_not parse('foo') }
+  it { should parse('example').as('example') }
+  it { should_not parse('foo').as('example') }
+  it { should_not parse('example').as('foo') }
+
+  it { str('foo').as(:bar).should parse('foo').as({:bar => 'foo'}) }
+  it { str('foo').as(:bar).should_not parse('foo').as({:b => 'f'}) }
+
+  it 'accepts a block to assert more specific details about the parsing output' do
+    str('foo').as(:bar).should(parse('foo').as { |output|
+      output.should have_key(:bar)
+      output.values.first.should == 'foo'
+    })
+  end
+
+  # Uncomment to test error messages manually: 
+  # it { str('foo').should parse('foo', :trace => true).as('bar') }
+  # it { str('foo').should parse('food', :trace => true) }
+  # it { str('foo').should_not parse('foo', :trace => true).as('foo') }
+  # it { str('foo').should_not parse('foo', :trace => true) }
+  # it 'accepts a block to assert more specific details about the parsing output' do
+  #   str('foo').as(:bar).should(parse('foo', :trace => true).as { |output|
+  #     output.should_not have_key(:bar)
+  #   })
+  # end
+  
+end
+
+describe 'rspec3 syntax' do
+  include Parsanol
+
+  let(:s) { str('example') }
+
+  it { expect(s).to parse('example') }
+  it { expect(s).not_to parse('foo') }
+  it { expect(s).to parse('example').as('example') }
+  it { expect(s).not_to parse('foo').as('example') }
+
+  it { expect(s).not_to parse('example').as('foo') }
+
+  # Uncomment to test error messages manually: 
+  # it { expect(str('foo')).to parse('foo', :trace => true).as('bar') }
+  # it { expect(str('foo')).to parse('food', :trace => true) }
+  # it { expect(str('foo')).not_to parse('foo', :trace => true).as('foo') }
+  # it { expect(str('foo')).not_to parse('foo', :trace => true) }
+end

data/spec/parsanol/rope_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Parsanol::Rope do
+  describe '#append' do
+    it 'appends strings' do
+      rope = described_class.new
+      rope.append('hello')
+      rope.append(' ')
+      rope.append('world')
+      expect(rope.to_s).to eq('hello world')
+    end
+
+    it 'appends Slices' do
+      rope = described_class.new
+      rope.append(Parsanol::Slice.new(0, 'hello'))
+      rope.append(Parsanol::Slice.new(5, ' world'))
+      expect(rope.to_s).to eq('hello world')
+    end
+
+    it 'appends mixed strings and Slices' do
+      rope = described_class.new
+      rope.append('hello')
+      rope.append(Parsanol::Slice.new(5, ' '))
+      rope.append('world')
+      expect(rope.to_s).to eq('hello world')
+    end
+
+    it 'returns self for chaining' do
+      rope = described_class.new
+      result = rope.append('a')
+      expect(result).to equal(rope)
+    end
+
+    it 'allows chaining multiple appends' do
+      rope = described_class.new
+      rope.append('a').append('b').append('c')
+      expect(rope.to_s).to eq('abc')
+    end
+
+    it 'freezes after to_s' do
+      rope = described_class.new.append('test')
+      rope.to_s
+      expect { rope.append('more') }.to raise_error(FrozenError)
+    end
+
+    it 'raises FrozenError with descriptive message' do
+      rope = described_class.new.append('test')
+      rope.to_s
+      expect { rope.append('more') }.to raise_error(FrozenError, /frozen Rope/)
+    end
+
+    it 'handles empty string segments' do
+      rope = described_class.new
+      rope.append('hello')
+      rope.append('')
+      rope.append('world')
+      expect(rope.to_s).to eq('helloworld')
+    end
+  end
+
+  describe '#to_s' do
+    it 'joins all segments' do
+      rope = described_class.new
+      rope.append('a').append('b').append('c')
+      expect(rope.to_s).to eq('abc')
+    end
+
+    it 'handles empty rope' do
+      rope = described_class.new
+      expect(rope.to_s).to eq('')
+    end
+
+    it 'handles single segment' do
+      rope = described_class.new.append('test')
+      expect(rope.to_s).to eq('test')
+    end
+
+    it 'joins Slice objects correctly' do
+      rope = described_class.new
+      rope.append(Parsanol::Slice.new(0, 'first'))
+      rope.append(Parsanol::Slice.new(5, 'second'))
+      expect(rope.to_s).to eq('firstsecond')
+    end
+
+    it 'can be called multiple times (idempotent)' do
+      rope = described_class.new.append('test')
+      result1 = rope.to_s
+      result2 = rope.to_s
+      expect(result1).to eq('test')
+      expect(result2).to eq('test')
+    end
+
+    it 'freezes the rope' do
+      rope = described_class.new.append('test')
+      expect(rope.to_s).to eq('test')
+      expect { rope.append('more') }.to raise_error(FrozenError)
+    end
+  end
+
+  describe '#empty?' do
+    it 'returns true for new rope' do
+      rope = described_class.new
+      expect(rope.empty?).to be true
+    end
+
+    it 'returns false after append' do
+      rope = described_class.new.append('x')
+      expect(rope.empty?).to be false
+    end
+
+    it 'returns false after appending empty string' do
+      rope = described_class.new.append('')
+      expect(rope.empty?).to be false
+    end
+
+    it 'returns false after appending Slice' do
+      rope = described_class.new.append(Parsanol::Slice.new(0, 'x'))
+      expect(rope.empty?).to be false
+    end
+  end
+
+  describe '#size' do
+    it 'returns 0 for empty rope' do
+      rope = described_class.new
+      expect(rope.size).to eq(0)
+    end
+
+    it 'estimates total size for strings' do
+      rope = described_class.new
+      rope.append('hello').append('world')
+      expect(rope.size).to eq(10)
+    end
+
+    it 'estimates total size for Slices' do
+      rope = described_class.new
+      rope.append(Parsanol::Slice.new(0, 'hello'))
+      rope.append(Parsanol::Slice.new(5, 'world'))
+      expect(rope.size).to eq(10)
+    end
+
+    it 'estimates total size for mixed segments' do
+      rope = described_class.new
+      rope.append('hello')
+      rope.append(Parsanol::Slice.new(5, ' '))
+      rope.append('world')
+      expect(rope.size).to eq(11)
+    end
+
+    it 'handles empty string segments' do
+      rope = described_class.new
+      rope.append('hello')
+      rope.append('')
+      rope.append('world')
+      expect(rope.size).to eq(10)
+    end
+  end
+
+  describe '.from_string' do
+    it 'creates rope from string' do
+      rope = described_class.from_string('test')
+      expect(rope.to_s).to eq('test')
+    end
+
+    it 'handles empty string' do
+      rope = described_class.from_string('')
+      expect(rope.empty?).to be true
+      expect(rope.to_s).to eq('')
+    end
+
+    it 'creates a new rope instance each time' do
+      rope1 = described_class.from_string('test')
+      rope2 = described_class.from_string('test')
+      expect(rope1).not_to equal(rope2)
+    end
+
+    it 'allows further appends' do
+      rope = described_class.from_string('hello')
+      rope.append(' world')
+      expect(rope.to_s).to eq('hello world')
+    end
+  end
+
+  describe 'integration scenarios' do
+    it 'handles complex concatenation patterns' do
+      rope = described_class.new
+      100.times { |i| rope.append(i.to_s) }
+      result = rope.to_s
+      expected = (0...100).map(&:to_s).join
+      expect(result).to eq(expected)
+    end
+
+    it 'handles Unicode strings' do
+      rope = described_class.new
+      rope.append('Hello')
+      rope.append(' ')
+      rope.append('世界')
+      expect(rope.to_s).to eq('Hello 世界')
+    end
+
+    it 'handles multi-byte characters in size calculation' do
+      rope = described_class.new
+      rope.append('Hello ')
+      rope.append('世界')
+      expect(rope.size).to eq(8)  # 6 ASCII + 2 multi-byte chars (counted as chars, not bytes)
+    end
+  end
+end

data/spec/parsanol/scope_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Parsanol::Scope do
+  let(:scope) { described_class.new }
+  
+  describe 'simple store/retrieve' do
+    before(:each) { scope[:foo] = :bar }
+    it "allows storing objects" do
+      scope[:obj] = 42
+    end 
+    it "raises on access of empty slots" do
+      expect {
+        scope[:empty]
+      }.to raise_error(Parsanol::Scope::NotFound)
+    end 
+    it "allows retrieval of stored values" do
+      scope[:foo].should == :bar
+    end 
+  end
+  
+  describe 'scoping' do
+    before(:each) { scope[:depth] = 1 }
+    before(:each) { scope.push }
+    
+    let(:depth) { scope[:depth] }
+    subject { depth }
+    
+    it { should == 1 }
+    describe 'after a push' do
+      before(:each) { scope.push }
+      it { should == 1 }
+      
+      describe 'and reassign' do
+        before(:each) { scope[:depth] = 2 }
+        
+        it { should == 2 }
+
+        describe 'and a pop' do
+          before(:each) { scope.pop }
+          it { should == 1 }
+        end
+      end
+    end
+  end
+end