parsanol 3.0.0

data/spec/parsanol/cut_inserter_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+describe Parsanol::Optimizers::CutInserter do
+  include Parsanol
+
+  let(:inserter) { Parsanol::Optimizers::CutInserter.new }
+
+  describe "basic functionality" do
+    it "returns parslet unchanged if not an alternative" do
+      parslet = str('hello')
+      result = inserter.optimize(parslet)
+      expect(result.to_s).to include('hello')
+    end
+
+    it "returns sequence unchanged if no alternatives inside" do
+      parslet = str('a') >> str('b')
+      result = inserter.optimize(parslet)
+      # Note: Phase 24 may optimize this to str('ab')
+      expect(result).to be_a(Parsanol::Atoms::Base)
+    end
+  end
+
+  describe "disjoint alternatives" do
+    it "inserts cuts for simple disjoint alternatives" do
+      parslet = str('if') | str('while') | str('print')
+      result = inserter.optimize(parslet)
+
+      # Should insert cuts in each alternative
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      result.alternatives.each do |alt|
+        # Each alternative should be wrapped with cut
+        expect(alt).to be_a(Parsanol::Atoms::Cut)
+      end
+    end
+
+    it "inserts cuts for two disjoint alternatives" do
+      parslet = str('yes') | str('no')
+      result = inserter.optimize(parslet)
+
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      expect(result.alternatives.size).to eq(2)
+      result.alternatives.each do |alt|
+        expect(alt).to be_a(Parsanol::Atoms::Cut)
+      end
+    end
+
+    it "inserts cuts after deterministic prefix in sequences" do
+      # Note: Phase 24 may concatenate adjacent strings
+      # So str('if') >> str(' ') >> str('x') may become str('if x')
+      parslet = (str('if') >> str(' ') >> str('x')) |
+                (str('while') >> str(' ') >> str('y'))
+      result = inserter.optimize(parslet)
+
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      # Each alternative should be wrapped with cut
+      # (May be Cut wrapping whole thing if Phase 24 concatenated strings)
+      result.alternatives.each do |alt|
+        expect(alt).to be_a(Parsanol::Atoms::Cut)
+      end
+    end
+  end
+
+  describe "overlapping alternatives" do
+    it "does not insert cuts when FIRST sets overlap" do
+      # Same atom in both alternatives - not disjoint
+      atom = str('same')
+      parslet = atom | atom
+      result = inserter.optimize(parslet)
+
+      # Should not insert cuts
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      result.alternatives.each do |alt|
+        expect(alt).not_to be_a(Parsanol::Atoms::Cut)
+      end
+    end
+  end
+
+  describe "EPSILON handling" do
+    it "does not cut after parslets with EPSILON in FIRST set" do
+      # str('a').maybe has EPSILON in FIRST set
+      parslet = (str('a').maybe >> str('b')) |
+                (str('c') >> str('d'))
+      result = inserter.optimize(parslet)
+
+      # First alternative has EPSILON, so shouldn't have cut at start
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      first_alt = result.alternatives[0]
+      # The sequence may be optimized but should still have structure
+      # Second alternative should be wrapped with cut since 'cd' is deterministic
+      second_alt = result.alternatives[1]
+      expect(second_alt).to be_a(Parsanol::Atoms::Cut)
+    end
+
+    it "cuts after non-EPSILON prefix even if later elements have EPSILON" do
+      # str('if') doesn't have EPSILON, safe to cut after it
+      parslet = (str('if') >> str('x').maybe >> str('y')) |
+                (str('while') >> str('z'))
+      result = inserter.optimize(parslet)
+
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      # First alternative should have cut after 'if'
+      first_alt = result.alternatives[0]
+      expect(first_alt).to be_a(Parsanol::Atoms::Sequence)
+      # First element should be a cut wrapping 'if'
+      expect(first_alt.parslets.first).to be_a(Parsanol::Atoms::Cut)
+    end
+  end
+
+  describe "nested alternatives" do
+    it "recursively optimizes nested alternatives" do
+      # Outer alternative: 'a' | (inner alternative)
+      # Inner alternative: 'b' | 'c'
+      inner = str('b') | str('c')
+      outer = str('a') | inner
+
+      result = inserter.optimize(outer)
+
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      # Outer should have 2 alternatives
+      expect(result.alternatives.size).to eq(2)
+
+      # First should be wrapped with cut
+      expect(result.alternatives[0]).to be_a(Parsanol::Atoms::Cut)
+
+      # Second alternative should be the optimized inner alternative
+      # It will be a Cut-wrapped Alternative
+      second = result.alternatives[1]
+      # The inner alternative was optimized and wrapped
+      # Structure: outer sees flattened alternatives OR nested structure
+      # Just verify both alternatives have cuts applied somewhere
+      expect(result.to_s).to include('↑')
+    end
+  end
+
+  describe "repetitions" do
+    it "recursively optimizes alternatives inside repetitions" do
+      parslet = (str('a') | str('b')).repeat(1, 3)
+      result = inserter.optimize(parslet)
+
+      expect(result).to be_a(Parsanol::Atoms::Repetition)
+      # The inner alternative should be optimized
+      inner = result.parslet
+      expect(inner).to be_a(Parsanol::Atoms::Alternative)
+      inner.alternatives.each do |alt|
+        expect(alt).to be_a(Parsanol::Atoms::Cut)
+      end
+    end
+  end
+
+  describe "named atoms" do
+    it "recursively optimizes named alternatives" do
+      parslet = (str('x') | str('y')).as(:choice)
+      result = inserter.optimize(parslet)
+
+      expect(result).to be_a(Parsanol::Atoms::Named)
+      expect(result.name).to eq(:choice)
+
+      # The wrapped alternative should be optimized
+      inner = result.parslet
+      expect(inner).to be_a(Parsanol::Atoms::Alternative)
+      inner.alternatives.each do |alt|
+        expect(alt).to be_a(Parsanol::Atoms::Cut)
+      end
+    end
+  end
+
+  describe "complex grammars" do
+    it "optimizes statement-like grammar" do
+      # Simulates: if_stmt | while_stmt | print_stmt
+      # Each statement has keyword followed by other stuff
+      # Note: Phase 24 may concatenate these into single strings
+      if_stmt = str('if') >> str(' ') >> str('condition')
+      while_stmt = str('while') >> str(' ') >> str('condition')
+      print_stmt = str('print') >> str(' ') >> str('expr')
+
+      parslet = if_stmt | while_stmt | print_stmt
+      result = inserter.optimize(parslet)
+
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+      expect(result.alternatives.size).to eq(3)
+
+      # Each alternative should have a cut somewhere
+      # The exact structure depends on Phase 24 optimization
+      result.alternatives.each do |alt|
+        # Should be either Cut or Sequence with Cut
+        expect([Parsanol::Atoms::Cut, Parsanol::Atoms::Sequence]).to include(alt.class)
+      end
+    end
+
+    it "handles mixed safe and unsafe alternatives correctly" do
+      # If FIRST sets aren't all disjoint, no cuts
+      parslet = str('a') >> str('b') |
+                str('a') >> str('c')  # Both start with 'a' - not disjoint!
+
+      result = inserter.optimize(parslet)
+
+      # Should not insert cuts since FIRST sets overlap
+      # Note: str('a') >> str('b') might be optimized to str('ab') by Phase 24
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+    end
+  end
+
+  describe "edge cases" do
+    it "handles single alternative (no optimization needed)" do
+      # Alternative with one option - trivial case
+      parslet = Parsanol::Atoms::Alternative.new(str('only'))
+      result = inserter.optimize(parslet)
+
+      # Should still work, just return optimized single alternative
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+    end
+
+    it "handles empty sequence prefix (no cut insertion)" do
+      # If prefix is empty, shouldn't insert cut
+      parslet = (str('a').maybe >> str('b')) | str('c')
+      result = inserter.optimize(parslet)
+
+      # Alternatives are disjoint but first has EPSILON prefix
+      expect(result).to be_a(Parsanol::Atoms::Alternative)
+    end
+  end
+
+  describe "preservation of semantics" do
+    it "produces parslet that parses the same input" do
+      parslet = str('if') | str('while') | str('for')
+      optimized = inserter.optimize(parslet)
+
+      # Should parse same inputs
+      expect(parslet.parse('if')).to eq('if')
+      expect(optimized.parse('if')).to eq('if')
+
+      expect(parslet.parse('while')).to eq('while')
+      expect(optimized.parse('while')).to eq('while')
+
+      expect(parslet.parse('for')).to eq('for')
+      expect(optimized.parse('for')).to eq('for')
+    end
+
+    it "produces parslet that fails on same invalid input" do
+      parslet = str('yes') | str('no')
+      optimized = inserter.optimize(parslet)
+
+      # Both should fail on invalid input
+      expect { parslet.parse('maybe') }.to raise_error(Parsanol::ParseFailed)
+      expect { optimized.parse('maybe') }.to raise_error(Parsanol::ParseFailed)
+    end
+  end
+end

data/spec/parsanol/cut_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe "Cut operator" do
+  include Parsanol
+
+  describe "basic functionality" do
+    it "allows successful parse when cut succeeds" do
+      parser = str('if').cut >> str(' ') >> str('x')
+      result = parser.parse('if x')
+      expect(result).to eq('if x')
+    end
+
+    it "provides cache eviction on successful cut" do
+      # Cut operator primarily provides cache eviction for memory optimization
+      # It clears cache before the cut position
+      parser = str('if').cut >> str('x')
+      result = parser.parse('ifx')
+      expect(result).to eq('ifx')
+    end
+  end
+
+  describe "with alternatives" do
+    it "works with cuts in each alternative branch" do
+      parser =
+        (str('if').cut >> str(' then')) |
+        (str('while').cut >> str(' do')) |
+        str('print')
+
+      expect(parser.parse('if then')).to eq('if then')
+      expect(parser.parse('while do')).to eq('while do')
+      expect(parser.parse('print')).to eq('print')
+    end
+  end
+
+  describe "cut position" do
+    it "cuts at the correct position" do
+      parser = str('a').cut >> str('b') >> str('c')
+      result = parser.parse('abc')
+      expect(result).to eq('abc')
+    end
+  end
+
+  describe "FIRST set delegation" do
+    it "delegates first_set to wrapped parslet" do
+      cut_atom = str('test').cut
+      expect(cut_atom.first_set.size).to eq(1)
+      expect(cut_atom.first_set.first).to be_a(Parsanol::Atoms::Str)
+      expect(cut_atom.first_set.first.str).to eq('test')
+    end
+  end
+
+  describe "caching behavior" do
+    it "is not cached itself (thin wrapper)" do
+      cut_atom = str('test').cut
+      expect(cut_atom.cached?).to be false
+    end
+  end
+
+  describe "string representation" do
+    it "shows cut operator in to_s" do
+      cut_atom = str('foo').cut
+      expect(cut_atom.to_s).to include('foo')
+      expect(cut_atom.to_s).to include('↑')
+    end
+  end
+end

data/spec/parsanol/edit_tracker_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+require 'parsanol/edit_tracker'
+
+describe Parsanol::EditTracker do
+  let(:tracker) { Parsanol::EditTracker.new }
+
+  describe '#initialize' do
+    it 'creates an empty tracker' do
+      expect(tracker.empty?).to be true
+      expect(tracker.size).to eq 0
+    end
+  end
+
+  describe '#insert and #delete' do
+    it 'records insertions' do
+      tracker.insert(10, 5)
+      expect(tracker.size).to eq 1
+      expect(tracker.edits.first.position).to eq 10
+      expect(tracker.edits.first.delta).to eq 5
+    end
+
+    it 'records deletions' do
+      tracker.delete(20, 3)
+      expect(tracker.size).to eq 1
+      expect(tracker.edits.first.position).to eq 20
+      expect(tracker.edits.first.delta).to eq(-3)
+    end
+
+    it 'records multiple edits in order' do
+      tracker.insert(10, 5)
+      tracker.delete(30, 2)
+      tracker.insert(50, 10)
+
+      expect(tracker.size).to eq 3
+      expect(tracker.edits[0].delta).to eq 5
+      expect(tracker.edits[1].delta).to eq(-2)
+      expect(tracker.edits[2].delta).to eq 10
+    end
+  end
+
+  describe '#shift_interval' do
+    context 'with no edits' do
+      it 'returns the original interval' do
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [10, 20]
+      end
+    end
+
+    context 'with edit before interval' do
+      it 'shifts both boundaries forward for insertion' do
+        tracker.insert(5, 10)  # Insert 10 chars at position 5
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [20, 30]  # Both shifted by +10
+      end
+
+      it 'shifts both boundaries backward for deletion' do
+        tracker.delete(5, 3)  # Delete 3 chars at position 5
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [7, 17]  # Both shifted by -3
+      end
+    end
+
+    context 'with edit after interval' do
+      it 'does not shift interval for insertion' do
+        tracker.insert(50, 10)
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [10, 20]  # No change
+      end
+
+      it 'does not shift interval for deletion' do
+        tracker.delete(50, 5)
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [10, 20]  # No change
+      end
+    end
+
+    context 'with edit inside interval' do
+      it 'invalidates interval for insertion' do
+        tracker.insert(15, 5)  # Insert inside [10, 20)
+        result = tracker.shift_interval(10, 20)
+        expect(result).to be_nil  # Invalidated
+      end
+
+      it 'invalidates interval for deletion' do
+        tracker.delete(15, 3)  # Delete inside [10, 20)
+        result = tracker.shift_interval(10, 20)
+        expect(result).to be_nil  # Invalidated
+      end
+
+      it 'invalidates interval for edit at start boundary' do
+        tracker.insert(10, 5)  # Edit at start of [10, 20)
+        result = tracker.shift_interval(10, 20)
+        expect(result).to be_nil  # Invalidated
+      end
+    end
+
+    context 'with edit at end boundary' do
+      it 'does not invalidate interval' do
+        tracker.insert(20, 5)  # Edit at end of [10, 20) - not inside
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [10, 20]  # Not invalidated
+      end
+    end
+
+    context 'with multiple edits' do
+      it 'applies all edits in order' do
+        tracker.insert(5, 10)   # Shift [10,20) to [20,30)
+        tracker.insert(3, 5)    # Shift [20,30) to [25,35)
+        tracker.delete(2, 1)    # Shift [25,35) to [24,34)
+
+        result = tracker.shift_interval(10, 20)
+        expect(result).to eq [24, 34]
+      end
+
+      it 'invalidates if any edit is inside interval' do
+        tracker.insert(5, 10)   # Shift [10,20) to [20,30)
+        tracker.insert(25, 5)   # Inside shifted interval [20,30)
+
+        result = tracker.shift_interval(10, 20)
+        expect(result).to be_nil  # Invalidated by second edit
+      end
+
+      it 'handles complex sequence of edits' do
+        # Start with interval [100, 200)
+        tracker.insert(50, 20)    # Shift to [120, 220)
+        tracker.delete(80, 10)    # Shift to [110, 210)
+        tracker.insert(250, 30)   # After interval, no shift
+        tracker.insert(90, 5)     # Shift to [115, 215)
+
+        result = tracker.shift_interval(100, 200)
+        expect(result).to eq [115, 215]
+      end
+    end
+
+    context 'with invalidation conditions' do
+      it 'invalidates if shifted interval becomes negative' do
+        tracker.delete(5, 20)  # Large deletion before interval
+        result = tracker.shift_interval(10, 20)
+        expect(result).to be_nil  # Would become [<0, <0)
+      end
+
+      it 'invalidates if high becomes less than low' do
+        tracker.delete(5, 100)  # Very large deletion
+        result = tracker.shift_interval(10, 20)
+        expect(result).to be_nil  # Would become invalid
+      end
+    end
+  end
+
+  describe '#invalidates?' do
+    it 'returns false when interval is valid after edits' do
+      tracker.insert(5, 10)
+      expect(tracker.invalidates?(20, 30)).to be false
+    end
+
+    it 'returns true when interval is invalidated' do
+      tracker.insert(15, 5)
+      expect(tracker.invalidates?(10, 20)).to be true
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all edits' do
+      tracker.insert(10, 5)
+      tracker.delete(20, 3)
+      tracker.clear
+
+      expect(tracker.empty?).to be true
+      expect(tracker.size).to eq 0
+    end
+
+    it 'resets interval shifting' do
+      tracker.insert(5, 10)
+      tracker.clear
+
+      result = tracker.shift_interval(10, 20)
+      expect(result).to eq [10, 20]  # No shift after clear
+    end
+  end
+
+  describe 'edge cases' do
+    it 'handles zero-length intervals' do
+      tracker.insert(10, 5)
+      result = tracker.shift_interval(15, 15)
+      expect(result).to eq [20, 20]  # Shifted but still zero-length
+    end
+
+    it 'handles zero-length insertions' do
+      tracker.insert(10, 0)
+      result = tracker.shift_interval(5, 15)
+      expect(result).to eq [5, 15]  # No change
+    end
+
+    it 'handles zero-length deletions' do
+      tracker.delete(10, 0)
+      result = tracker.shift_interval(5, 15)
+      expect(result).to eq [5, 15]  # No change
+    end
+
+    it 'handles negative positions in edits' do
+      tracker.insert(-5, 10)
+      result = tracker.shift_interval(10, 20)
+      expect(result).to eq [20, 30]  # Shifted
+    end
+  end
+
+  describe 'Edit#to_s' do
+    it 'describes insertions' do
+      edit = Parsanol::EditTracker::Edit.new(10, 5)
+      expect(edit.to_s).to eq "Insert(5 chars at 10)"
+    end
+
+    it 'describes deletions' do
+      edit = Parsanol::EditTracker::Edit.new(20, -3)
+      expect(edit.to_s).to eq "Delete(3 chars at 20)"
+    end
+  end
+end

data/spec/parsanol/error_reporter/contextual_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Parsanol::ErrorReporter::Contextual do
+  let(:reporter) { described_class.new }
+  let(:fake_source) { double('source') }
+  let(:fake_atom) { double('atom') }
+  let(:fake_cause) { double('cause') }
+
+  describe '#err' do
+    before do
+      allow(fake_source).to receive(:pos).and_return(13)
+      allow(fake_source).to receive(:line_and_column).and_return([1, 1])
+    end
+
+    it 'returns the deepest cause' do
+      expect(reporter).to receive(:deepest).and_return(:deepest)
+      expect(reporter.err('parslet', fake_source, 'message')).to eq(:deepest)
+    end
+  end
+
+  describe '#err_at' do
+    before do
+      allow(fake_source).to receive(:pos).and_return(13)
+      allow(fake_source).to receive(:line_and_column).and_return([1, 1])
+    end
+
+    it 'returns the deepest cause' do
+      expect(reporter).to receive(:deepest).and_return(:deepest)
+      expect(reporter.err('parslet', fake_source, 'message', 13)).to eq(:deepest)
+    end
+  end
+
+  describe '#deepest(cause)' do
+    def fake_cause(pos = 13, children = nil)
+      double('cause' + pos.to_s, pos: pos, children: children)
+    end
+
+    context 'when there is no deepest cause yet' do
+      let(:cause) { fake_cause }
+
+      it 'returns the given cause' do
+        reporter.deepest(cause).should == cause
+      end
+    end
+
+    context 'when the previous cause is deeper (no relationship)' do
+      let(:previous) { fake_cause }
+
+      before do
+        reporter.deepest(previous)
+      end
+
+      it 'returns the previous cause' do
+        reporter.deepest(fake_cause(12))
+          .should == previous
+      end
+    end
+
+    context 'when the previous cause is deeper (child)' do
+      let(:previous) { fake_cause }
+
+      before do
+        reporter.deepest(previous)
+      end
+
+      it 'returns the given cause' do
+        given = fake_cause(12, [previous])
+        reporter.deepest(given).should == given
+      end
+    end
+
+    context 'when the previous cause is shallower' do
+      before do
+        reporter.deepest(fake_cause)
+      end
+
+      it 'stores the cause as deepest' do
+        deeper = fake_cause(14)
+        reporter.deepest(deeper)
+        reporter.deepest_cause.should == deeper
+      end
+    end
+  end
+
+  describe '#reset' do
+    before do
+      allow(fake_source).to receive(:pos).and_return(Parsanol::Position.new(
+                                                       "source", 13, 13
+                                                     ))
+      allow(fake_source).to receive(:line_and_column).and_return([1, 1])
+    end
+
+    it 'resets deepest cause on success of sibling expression' do
+      expect(reporter).to receive(:deepest).and_return(:deepest)
+      expect(reporter.err('parslet', fake_source, 'message')).to eq(:deepest)
+      expect(reporter).to receive(:reset).once
+      reporter.succ(fake_source)
+    end
+  end
+
+  describe 'label' do
+    before do
+      allow(fake_source).to receive(:pos).and_return(Parsanol::Position.new(
+                                                       "source", 13, 13
+                                                     ))
+      allow(fake_source).to receive(:line_and_column).and_return([1, 1])
+    end
+
+    it 'sets label if atom has one' do
+      expect(fake_atom).to receive(:label).once.and_return('label')
+      expect(fake_cause).to receive(:set_label).once
+      expect(reporter).to receive(:deepest).and_return(fake_cause)
+      expect(reporter.err(fake_atom, fake_source, 'message')).to eq(fake_cause)
+    end
+
+    it 'does not set label if atom does not have one' do
+      expect(reporter).to receive(:deepest).and_return(:deepest)
+      expect(fake_atom).not_to receive(:update_label)
+      expect(reporter.err(fake_atom, fake_source, 'message')).to eq(:deepest)
+    end
+  end
+end