plurimath-parslet 3.0.0

data/spec/examples/readme_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+require 'fixtures/examples/readme'
+
+RSpec.describe 'Readme Example' do
+  include ReadmeExample
+
+  describe 'basic parslet functionality' do
+    context 'string parsing' do
+      it 'parses simple strings' do
+        parser = str('foo')
+        result = parser.parse('foo')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('foo')
+      end
+
+      it 'fails on non-matching strings' do
+        parser = str('foo')
+        expect { parser.parse('bar') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    context 'character set matching' do
+      let(:parser) { Parslet.match('[abc]') }
+
+      it 'matches character a' do
+        result = parser.parse('a')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('a')
+      end
+
+      it 'matches character b' do
+        result = parser.parse('b')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('b')
+      end
+
+      it 'matches character c' do
+        result = parser.parse('c')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('c')
+      end
+
+      it 'fails on non-matching characters' do
+        expect { parser.parse('d') }.to raise_error(Parslet::ParseFailed)
+        expect { parser.parse('x') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    context 'annotation' do
+      it 'annotates output with symbols' do
+        parser = str('foo').as(:important_bit)
+        result = parser.parse('foo')
+        expect(result).to eq({ important_bit: 'foo' })
+      end
+
+      it 'preserves slice information in annotations' do
+        parser = str('hello').as(:greeting)
+        result = parser.parse('hello')
+        expect(result[:greeting]).to be_a(Parslet::Slice)
+        expect(result[:greeting].to_s).to eq('hello')
+      end
+    end
+  end
+
+  describe 'demo methods' do
+    describe '.demo_basic_parsing' do
+      it 'returns hash with all basic parsing results' do
+        result = ReadmeExample.demo_basic_parsing
+
+        expect(result).to be_a(Hash)
+        expect(result.keys).to contain_exactly(:foo, :a, :b, :c, :annotated)
+
+        # Check individual results
+        expect(result[:foo].to_s).to eq('foo')
+        expect(result[:a].to_s).to eq('a')
+        expect(result[:b].to_s).to eq('b')
+        expect(result[:c].to_s).to eq('c')
+        expect(result[:annotated]).to eq({ important_bit: 'foo' })
+      end
+    end
+
+    describe '.demo_simple_string' do
+      it 'parses quoted strings' do
+        result = ReadmeExample.demo_simple_string
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('"Simple Simple Simple"')
+      end
+    end
+
+    describe '.demo_smalltalk' do
+      it 'parses smalltalk keyword' do
+        result = ReadmeExample.demo_smalltalk
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('smalltalk')
+      end
+    end
+  end
+
+  describe ReadmeExample::SimpleStringParser do
+    let(:parser) { ReadmeExample::SimpleStringParser.new }
+
+    it 'parses simple quoted strings' do
+      result = parser.parse('"hello"')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('"hello"')
+    end
+
+    it 'parses strings with spaces' do
+      result = parser.parse('"hello world"')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('"hello world"')
+    end
+
+    it 'parses empty strings' do
+      result = parser.parse('""')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('""')
+    end
+
+    it 'parses strings with special characters' do
+      result = parser.parse('"hello!@#$%^&*()"')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('"hello!@#$%^&*()"')
+    end
+
+    it 'fails on unquoted strings' do
+      expect { parser.parse('hello') }.to raise_error(Parslet::ParseFailed)
+    end
+
+    it 'fails on unclosed quotes' do
+      expect { parser.parse('"hello') }.to raise_error(Parslet::ParseFailed)
+    end
+
+    it 'fails on strings starting without quote' do
+      expect { parser.parse('hello"') }.to raise_error(Parslet::ParseFailed)
+    end
+  end
+
+  describe ReadmeExample::SmalltalkParser do
+    let(:parser) { ReadmeExample::SmalltalkParser.new }
+
+    it 'parses smalltalk keyword' do
+      result = parser.parse('smalltalk')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('smalltalk')
+    end
+
+    it 'fails on other keywords' do
+      expect { parser.parse('ruby') }.to raise_error(Parslet::ParseFailed)
+      expect { parser.parse('python') }.to raise_error(Parslet::ParseFailed)
+    end
+
+    it 'fails on partial matches' do
+      expect { parser.parse('small') }.to raise_error(Parslet::ParseFailed)
+      expect { parser.parse('smalltalking') }.to raise_error(Parslet::ParseFailed)
+    end
+  end
+
+  describe 'integration with original readme examples' do
+    it 'reproduces str parsing example' do
+      result = str('foo').parse('foo')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('foo')
+    end
+
+    it 'reproduces match parsing examples' do
+      parser = Parslet.match('[abc]')
+      expect(parser.parse('a').to_s).to eq('a')
+      expect(parser.parse('b').to_s).to eq('b')
+      expect(parser.parse('c').to_s).to eq('c')
+    end
+
+    it 'reproduces annotation example' do
+      result = str('foo').as(:important_bit).parse('foo')
+      expect(result).to eq({ important_bit: 'foo' })
+    end
+
+    it 'reproduces simple string parser example' do
+      quote = str('"')
+      simple_string = quote >> (quote.absent? >> any).repeat >> quote
+      result = simple_string.parse('"Simple Simple Simple"')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('"Simple Simple Simple"')
+    end
+
+    it 'reproduces smalltalk parser example' do
+      parser = ReadmeExample::SmalltalkParser.new
+      result = parser.parse('smalltalk')
+      expect(result).to be_a(Parslet::Slice)
+      expect(result.to_s).to eq('smalltalk')
+    end
+  end
+
+  describe 'error handling' do
+    it 'provides meaningful error messages for string parsing' do
+      expect { str('foo').parse('bar') }.to raise_error(Parslet::ParseFailed, /Expected "foo"/)
+    end
+
+    it 'provides meaningful error messages for character set parsing' do
+      expect { Parslet.match('[abc]').parse('x') }.to raise_error(Parslet::ParseFailed, /Failed to match \[abc\]/)
+    end
+
+    it 'handles empty input appropriately' do
+      expect { str('foo').parse('') }.to raise_error(Parslet::ParseFailed)
+      expect { Parslet.match('[abc]').parse('') }.to raise_error(Parslet::ParseFailed)
+    end
+  end
+
+  describe 'edge cases' do
+    it 'handles whitespace in string parsing' do
+      parser = str(' ')
+      result = parser.parse(' ')
+      expect(result.to_s).to eq(' ')
+    end
+
+    it 'handles special characters in match parsing' do
+      parser = Parslet.match('[\n\t]')
+      expect(parser.parse("\n").to_s).to eq("\n")
+      expect(parser.parse("\t").to_s).to eq("\t")
+    end
+
+    it 'handles unicode characters' do
+      parser = str('café')
+      result = parser.parse('café')
+      expect(result.to_s).to eq('café')
+    end
+  end
+end

data/spec/examples/scopes_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+require 'fixtures/examples/scopes'
+
+RSpec.describe 'Scopes Example' do
+  include ScopesExample
+
+  describe 'ScopesExample basic scoping' do
+    describe '.create_parser' do
+      let(:parser) { ScopesExample.create_parser }
+
+      it 'returns a parslet atom' do
+        expect(parser).to respond_to(:parse)
+      end
+
+      it 'parses the expected scoped pattern "aba"' do
+        result = parser.parse('aba')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('aba')
+      end
+
+      it 'demonstrates scope behavior - captures work as expected' do
+        # The parser: str('a').capture(:a) >> scope { str('b').capture(:a) } >> dynamic { |s,c| str(c.captures[:a]) }
+        # First captures 'a' as :a, then in scope captures 'b' as :a
+        # The dynamic part uses the outer :a capture (which is 'a') to match the last character
+        # So it should parse 'aba'
+        result = parser.parse('aba')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('aba')
+      end
+
+      it 'fails when dynamic part does not match outer capture' do
+        # Should fail because the last character should match the outer capture 'a', not 'b'
+        expect { parser.parse('abb') }.to raise_error(Parslet::ParseFailed)
+      end
+
+      it 'fails on completely invalid input' do
+        expect { parser.parse('xyz') }.to raise_error(Parslet::ParseFailed)
+      end
+
+      it 'fails on partial input' do
+        expect { parser.parse('ab') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    describe '.parse_scoped_input' do
+      it 'parses default input successfully' do
+        # Default should be 'aba' based on actual scoping behavior
+        result = ScopesExample.parse_scoped_input('aba')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('aba')
+      end
+
+      it 'parses custom valid input' do
+        result = ScopesExample.parse_scoped_input('aba')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('aba')
+      end
+
+      it 'fails on invalid input' do
+        expect { ScopesExample.parse_scoped_input('abc') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    describe '.demonstrate_scope_success' do
+      it 'demonstrates successful scoped parsing' do
+        # This should work with the correct scoped pattern
+        result = ScopesExample.demonstrate_scope_success
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('aba')
+      end
+    end
+
+    describe '.demonstrate_scope_failure' do
+      it 'returns ParseFailed exception instead of raising it' do
+        result = ScopesExample.demonstrate_scope_failure
+        expect(result).to be_a(Parslet::ParseFailed)
+      end
+
+      it 'captures the error message' do
+        error = ScopesExample.demonstrate_scope_failure
+        expect(error.message).to be_a(String)
+        expect(error.message.length).to be > 0
+      end
+
+      it 'does not raise an exception' do
+        expect { ScopesExample.demonstrate_scope_failure }.not_to raise_error
+      end
+    end
+  end
+
+  describe 'ScopesExample nested scoping' do
+    describe '.create_nested_scope_parser' do
+      let(:parser) { ScopesExample.create_nested_scope_parser }
+
+      it 'returns a parslet atom' do
+        expect(parser).to respond_to(:parse)
+      end
+
+      it 'parses nested scoped pattern correctly' do
+        # Parser: str('x').capture(:outer) >> scope { str('y').capture(:outer) >> dynamic { |s,c| str(c.captures[:outer]) } } >> dynamic { |s,c| str(c.captures[:outer]) }
+        # Captures 'x' as :outer, then in scope 'y' shadows :outer, first dynamic uses 'y', then outer dynamic uses original 'x'
+        # So pattern should be: x y y x = 'xyyx'
+        result = parser.parse('xyyx')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('xyyx')
+      end
+
+      it 'fails on incorrect nested pattern' do
+        expect { parser.parse('xyzx') }.to raise_error(Parslet::ParseFailed)
+      end
+
+      it 'fails on partial input' do
+        expect { parser.parse('xy') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    describe '.parse_nested_scoped_input' do
+      it 'parses default nested input successfully' do
+        # Default should be 'xyyx' based on nested scoping
+        result = ScopesExample.parse_nested_scoped_input('xyyx')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('xyyx')
+      end
+
+      it 'parses custom valid nested input' do
+        result = ScopesExample.parse_nested_scoped_input('xyyx')
+        expect(result).to be_a(Parslet::Slice)
+        expect(result.to_s).to eq('xyyx')
+      end
+
+      it 'fails on invalid nested input' do
+        expect { ScopesExample.parse_nested_scoped_input('xyzx') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+  end
+
+  describe 'scope behavior demonstration' do
+    it 'shows how scopes work with captures' do
+      parser = ScopesExample.create_parser
+
+      # The parser demonstrates scope behavior with captures
+      # The dynamic part uses the outer :a capture (which is 'a')
+      result = parser.parse('aba')
+      expect(result.to_s).to eq('aba')
+    end
+
+    it 'shows nested scope behavior' do
+      parser = ScopesExample.create_nested_scope_parser
+
+      # Demonstrates multiple levels of scoping
+      result = parser.parse('xyyx')
+      expect(result.to_s).to eq('xyyx')
+    end
+
+    it 'demonstrates scope functionality' do
+      # Test the basic scoped parser
+      parser1 = ScopesExample.create_parser
+
+      # Should work with the correct pattern
+      expect(parser1.parse('aba').to_s).to eq('aba')
+    end
+  end
+
+  describe 'error handling' do
+    it 'provides meaningful error messages for scope violations' do
+      parser = ScopesExample.create_parser
+
+      begin
+        parser.parse('abc')
+        fail 'Expected ParseFailed to be raised'
+      rescue Parslet::ParseFailed => e
+        expect(e.message).to be_a(String)
+        expect(e.message.length).to be > 0
+      end
+    end
+
+    it 'handles empty input' do
+      parser = ScopesExample.create_parser
+      expect { parser.parse('') }.to raise_error(Parslet::ParseFailed)
+    end
+
+    it 'handles malformed input for nested scopes' do
+      parser = ScopesExample.create_nested_scope_parser
+      expect { parser.parse('invalid') }.to raise_error(Parslet::ParseFailed)
+    end
+  end
+end

data/spec/examples/seasons_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require_relative '../fixtures/examples/seasons'
+
+RSpec.describe 'Seasons Transform Example' do
+  let(:initial_tree) { { bud: { stem: [] } } }
+
+  describe SeasonsExample::Spring do
+    let(:spring) { SeasonsExample::Spring.new }
+
+    it 'adds a leaf branch to empty stems' do
+      tree = { stem: [] }
+      result = spring.apply(tree)
+      expect(result).to eq({ stem: [{ branch: :leaf }] })
+    end
+
+    it 'does not modify stems that are not empty arrays' do
+      # Spring only matches empty stems (sequence), not stems with existing content
+      tree = { stem: [{ branch: :existing }] }
+      result = spring.apply(tree)
+      expect(result).to eq({ stem: [{ branch: :existing }] })
+    end
+
+    it 'works with nested structures' do
+      tree = { bud: { stem: [] } }
+      result = spring.apply(tree)
+      expect(result).to eq({ bud: { stem: [{ branch: :leaf }] } })
+    end
+  end
+
+  describe SeasonsExample::Summer do
+    let(:summer) { SeasonsExample::Summer.new }
+
+    it 'transforms leaf branches to leaf and flower' do
+      tree = { stem: [{ branch: :leaf }] }
+      result = summer.apply(tree)
+      expect(result).to eq({ stem: [{ branch: [:leaf, :flower] }] })
+    end
+
+    it 'transforms multiple branches' do
+      tree = { stem: [{ branch: :leaf }, { branch: :leaf }] }
+      result = summer.apply(tree)
+      expect(result).to eq({ stem: [{ branch: [:leaf, :flower] }, { branch: [:leaf, :flower] }] })
+    end
+
+    it 'works with nested structures' do
+      tree = { bud: { stem: [{ branch: :leaf }] } }
+      result = summer.apply(tree)
+      expect(result).to eq({ bud: { stem: [{ branch: [:leaf, :flower] }] } })
+    end
+  end
+
+  describe SeasonsExample::Fall do
+    let(:fall) { SeasonsExample::Fall.new }
+
+    it 'empties branches and prints messages' do
+      tree = { branch: [:leaf, :flower] }
+
+      # Capture output
+      output = capture_output do
+        result = fall.apply(tree)
+        expect(result).to eq({ branch: [] })
+      end
+
+      expect(output).to include("Fruit!")
+      expect(output).to include("Falling Leaves!")
+    end
+
+    it 'handles branches with only leaves' do
+      tree = { branch: [:leaf] }
+
+      output = capture_output do
+        result = fall.apply(tree)
+        expect(result).to eq({ branch: [] })
+      end
+
+      expect(output).to include("Falling Leaves!")
+      expect(output).not_to include("Fruit!")
+    end
+
+    it 'handles branches with only flowers' do
+      tree = { branch: [:flower] }
+
+      output = capture_output do
+        result = fall.apply(tree)
+        expect(result).to eq({ branch: [] })
+      end
+
+      expect(output).to include("Fruit!")
+      expect(output).not_to include("Falling Leaves!")
+    end
+  end
+
+  describe SeasonsExample::Winter do
+    let(:winter) { SeasonsExample::Winter.new }
+
+    it 'empties all stems' do
+      tree = { stem: [{ branch: [] }, { branch: [] }] }
+      result = winter.apply(tree)
+      expect(result).to eq({ stem: [] })
+    end
+
+    it 'works with nested structures' do
+      tree = { bud: { stem: [{ branch: [] }] } }
+      result = winter.apply(tree)
+      expect(result).to eq({ bud: { stem: [] } })
+    end
+  end
+
+  describe 'do_seasons function' do
+    it 'cycles through all seasons correctly' do
+      tree = { bud: { stem: [] } }
+
+      output = capture_output do
+        result = SeasonsExample.do_seasons(tree)
+
+        # After all seasons, should be back to empty stem
+        expect(result).to eq({ bud: { stem: [] } })
+      end
+
+      # Should contain season announcements
+      expect(output).to include("And when SeasonsExample::Spring comes")
+      expect(output).to include("And when SeasonsExample::Summer comes")
+      expect(output).to include("And when SeasonsExample::Fall comes")
+      expect(output).to include("And when SeasonsExample::Winter comes")
+
+      # Should contain fall messages
+      expect(output).to include("Fruit!")
+      expect(output).to include("Falling Leaves!")
+    end
+  end
+
+  describe 'integration test' do
+    it 'processes the complete seasonal cycle' do
+      tree = { bud: { stem: [] } }
+
+      # Spring: adds leaf
+      spring = SeasonsExample::Spring.new
+      tree = spring.apply(tree)
+      expect(tree).to eq({ bud: { stem: [{ branch: :leaf }] } })
+
+      # Summer: leaf becomes leaf + flower
+      summer = SeasonsExample::Summer.new
+      tree = summer.apply(tree)
+      expect(tree).to eq({ bud: { stem: [{ branch: [:leaf, :flower] }] } })
+
+      # Fall: branch becomes empty
+      fall = SeasonsExample::Fall.new
+      output = capture_output do
+        tree = fall.apply(tree)
+      end
+      expect(tree).to eq({ bud: { stem: [{ branch: [] }] } })
+      expect(output).to include("Fruit!")
+      expect(output).to include("Falling Leaves!")
+
+      # Winter: stem becomes empty
+      winter = SeasonsExample::Winter.new
+      tree = winter.apply(tree)
+      expect(tree).to eq({ bud: { stem: [] } })
+    end
+
+    it 'runs two complete cycles as in the example' do
+      tree = { bud: { stem: [] } }
+
+      output = capture_output do
+        # First cycle
+        tree = SeasonsExample.do_seasons(tree)
+        expect(tree).to eq({ bud: { stem: [] } })
+
+        # Second cycle
+        tree = SeasonsExample.do_seasons(tree)
+        expect(tree).to eq({ bud: { stem: [] } })
+      end
+
+      # Should have two sets of season announcements
+      season_announcements = output.scan(/And when SeasonsExample::\w+ comes/).length
+      expect(season_announcements).to eq(8) # 4 seasons × 2 cycles
+
+      # Should have fruit and falling leaves messages from both cycles
+      fruit_count = output.scan(/Fruit!/).length
+      leaves_count = output.scan(/Falling Leaves!/).length
+      expect(fruit_count).to eq(2) # Once per cycle
+      expect(leaves_count).to eq(2) # Once per cycle
+    end
+  end
+
+  private
+
+  def capture_output
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+    $stdout.string
+  ensure
+    $stdout = original_stdout
+  end
+end