plurimath-parslet 3.0.0

data/spec/parslet/atoms/base_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Base do
+  let(:parslet) { Parslet::Atoms::Base.new }
+  let(:context) { Parslet::Atoms::Context.new }
+
+  describe '<- #try(io)' do
+    it 'raises NotImplementedError' do
+      lambda {
+        parslet.try(double(:io), context, false)
+      }.should raise_error(NotImplementedError)
+    end
+  end
+
+  describe '<- #flatten_sequence' do
+    [
+      # 9 possibilities for making a word of 2 letters from the alphabeth of
+      # A(rray), H(ash) and S(tring). Make sure that all results are valid.
+      #
+      %w[a b], 'ab',                             # S S
+      [['a'], ['b']], %w[a b],                   # A A
+      [{ a: 'a' }, { b: 'b' }], { a: 'a', b: 'b' }, # H H
+
+      [{ a: 'a' }, ['a']], [{ a: 'a' }, 'a'],         # H A
+      [{ a: 'a' }, 's'],   { a: 'a' },                # H S
+
+      [['a'], { a: 'a' }], ['a', { a: 'a' }],         # A H (symmetric to H A)
+      [['a'], 'b'], ['a'], # A S
+
+      ['a', { b: 'b' }], { b: 'b' }, # S H (symmetric to H S)
+      ['a', ['b']], ['b'],                          # S A (symmetric to A S)
+
+      [nil, ['a']], ['a'],                          # handling of lhs nil
+      [nil, { a: 'a' }], { a: 'a' },
+      [['a'], nil], ['a'],                          # handling of rhs nil
+      [{ a: 'a' }, nil], { a: 'a' }
+    ].each_slice(2) do |sequence, result|
+      context 'for ' + sequence.inspect do
+        it "equals #{result.inspect}" do
+          parslet.flatten_sequence(sequence).should == result
+        end
+      end
+    end
+  end
+
+  describe '<- #flatten_repetition' do
+    def unnamed(obj)
+      parslet.flatten_repetition(obj, false)
+    end
+
+    it 'gives subtrees precedence' do
+      unnamed([[{ a: 'a' }, { m: 'm' }], { a: 'a' }]).should == [{ a: 'a' }]
+    end
+  end
+
+  describe '#parse(source)' do
+    context 'when given something that looks like a source' do
+      let(:source) do
+        double('source lookalike',
+               line_and_column: [1, 2],
+               bytepos: 1,
+               chars_left: 0)
+      end
+
+      it 'does not rewrap in a source' do
+        expect(Parslet::Source).not_to receive(:new)
+
+        begin
+          parslet.parse(source)
+        rescue NotImplementedError
+        end
+      end
+    end
+  end
+
+  context 'when the parse fails, the exception' do
+    it 'contains a string' do
+      Parslet.str('foo').parse('bar')
+    rescue Parslet::ParseFailed => e
+      e.message.should be_kind_of(String)
+    end
+  end
+
+  context 'when not all input is consumed' do
+    let(:parslet) { Parslet.str('foo') }
+
+    it 'raises with a proper error message' do
+      error = catch_failed_parse do
+        parslet.parse('foobar')
+      end
+
+      error.to_s.should == "Don't know what to do with \"bar\" at line 1 char 4."
+    end
+  end
+
+  context 'when only parsing string prefix' do
+    let(:parslet) { Parslet.str('foo') >> Parslet.str('bar') }
+
+    it 'returns the first half on a prefix parse' do
+      parslet.parse('foobarbaz', prefix: true).should == 'foobar'
+    end
+  end
+
+  describe ':reporter option' do
+    let(:parslet) { Parslet.str('test') >> Parslet.str('ing') }
+    let(:reporter) { double(:reporter) }
+
+    it 'replaces the default reporter' do
+      cause = double(:cause)
+
+      # Two levels of the parse, calling two different error reporting
+      # methods.
+      expect(reporter).to receive(:err_at).once
+      expect(reporter).to receive(:err).and_return(cause).once
+      expect(reporter).to receive(:succ).once
+
+      # The final cause will be sent the #raise method.
+      expect(cause).to receive(:raise).once.and_throw(:raise)
+
+      catch(:raise) do
+        parslet.parse('testung', reporter: reporter)
+
+        raise 'NEVER REACHED'
+      end
+    end
+  end
+end

data/spec/parslet/atoms/capture_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Capture do
+  include Parslet
+  
+  let(:context) { Parslet::Atoms::Context.new(nil) }
+  
+  def inject string, parser
+    source = Parslet::Source.new(string)
+    parser.apply(source, context, true)
+  end
+  
+  it "should capture simple results" do
+    inject 'a', str('a').capture(:a)
+    context.captures[:a].should == 'a'
+  end 
+  it "should capture complex results" do
+    inject 'a', str('a').as(:b).capture(:a)
+    context.captures[:a].should == {:b => 'a'}
+  end 
+end

data/spec/parslet/atoms/combinations_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe "Parslet combinations" do
+  include Parslet
+end

data/spec/parslet/atoms/dsl_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::DSL do
+  describe "deprecated methods" do
+    let(:parslet) { Parslet.str('foo') }
+  end
+end

data/spec/parslet/atoms/entity_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Entity do
+  context "when constructed with str('bar') inside" do
+    let(:named) { Parslet::Atoms::Entity.new('name', &proc { Parslet.str('bar') }) }
+
+    it "should parse 'bar' without raising exceptions" do
+      named.parse('bar')
+    end 
+    it "should raise when applied to 'foo'" do
+      lambda {
+        named.parse('foo')
+      }.should raise_error(Parslet::ParseFailed)
+    end 
+
+    describe "#inspect" do
+      it "should return the name of the entity" do
+        named.inspect.should == 'NAME'
+      end 
+    end
+  end
+  context "when constructed with empty block" do
+    let(:entity) { Parslet::Atoms::Entity.new('name', &proc { }) }
+    
+    it "should raise NotImplementedError" do
+      lambda {
+        entity.parse('some_string')
+      }.should raise_error(NotImplementedError)
+    end 
+  end
+  
+  context "recursive definition parser" do
+    class RecDefParser
+      include Parslet
+      rule :recdef do
+        str('(') >> atom >> str(')')
+      end
+      rule :atom do
+        str('a') | str('b') | recdef
+      end
+    end
+    let(:parser) { RecDefParser.new }
+    
+    it "should parse balanced parens" do
+      parser.recdef.parse("(((a)))")
+    end
+    it "should not throw 'stack level too deep' when printing errors" do
+      cause = catch_failed_parse { parser.recdef.parse('(((a))') }
+      cause.ascii_tree
+    end
+  end
+
+  context "when constructed with a label" do
+    let(:named) { Parslet::Atoms::Entity.new('name', 'label', &proc { Parslet.str('bar') }) }
+
+    it "should parse 'bar' without raising exceptions" do
+      named.parse('bar')
+    end 
+    it "should raise when applied to 'foo'" do
+      lambda {
+        named.parse('foo')
+      }.should raise_error(Parslet::ParseFailed)
+    end 
+
+    describe "#inspect" do
+      it "should return the label of the entity" do
+        named.inspect.should == 'label'
+      end 
+    end
+
+    describe "#parslet" do
+      it "should set the label on the cached parslet" do
+        named.parslet.label.should == 'label'
+      end
+    end
+  end
+end

data/spec/parslet/atoms/ignored_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Ignored do
+  include Parslet
+
+  describe "ignore" do
+    it "ignores parts of the input" do
+      str('a').ignore.parse('a').should == nil
+      (str('a') >> str('b').ignore >> str('c')).parse('abc').should == 'ac'
+      (str('a') >> str('b').as(:name).ignore >> str('c')).parse('abc').should == 'ac'
+      (str('a') >> str('b').maybe.ignore >> str('c')).parse('abc').should == 'ac'
+      (str('a') >> str('b').maybe.ignore >> str('c')).parse('ac').should == 'ac'
+    end
+  end
+end

data/spec/parslet/atoms/infix_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Infix do
+
+end

data/spec/parslet/atoms/lookahead_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Lookahead do
+  include Parslet
+  
+  describe 'negative lookahead' do
+    it "influences the error tree" do
+      parser = str('f').absent? >> str('b')
+      cause = catch_failed_parse { parser.parse('f') }
+      
+      cause.ascii_tree.should == "Failed to match sequence (!'f' 'b') at line 1 char 1.\n`- Input should not start with 'f' at line 1 char 1.\n"
+    end 
+  end
+  describe 'positive lookahead' do
+    it "influences the error tree" do
+      parser = str('f').present? >> str('b')
+      cause = catch_failed_parse { parser.parse('b') }
+      
+      cause.ascii_tree.should == "Failed to match sequence (&'f' 'b') at line 1 char 1.\n`- Input should start with 'f' at line 1 char 1.\n"
+    end 
+  end
+end

data/spec/parslet/atoms/named_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Named do
+end

data/spec/parslet/atoms/re_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Re do
+  describe "construction" do
+    include Parslet
+
+    it "should allow match(str) form" do
+      Parslet.match('[a]').should be_a(Parslet::Atoms::Re)
+    end
+    it "should allow match[str] form" do
+      Parslet.match['a'].should be_a(Parslet::Atoms::Re)
+    end
+  end
+end

data/spec/parslet/atoms/repetition_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Repetition do
+  include Parslet
+
+  describe "repeat" do
+    let(:parslet) { str('a') }
+    
+    describe "(min, max)" do
+      subject { parslet.repeat(1,2) }
+      
+      it { should_not parse("") }
+      it { should parse("a") }
+      it { should parse("aa") }
+    end
+    describe "0 times" do
+      it "raises an ArgumentError" do
+        expect {
+          parslet.repeat(0,0)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/parslet/atoms/scope_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Scope do
+  include Parslet
+  include Parslet::Atoms::DSL
+
+
+  let(:context) { Parslet::Atoms::Context.new(nil) }
+  let(:captures) { context.captures }
+
+  def inject string, parser
+    source = Parslet::Source.new(string)
+    parser.apply(source, context, true)
+  end
+
+  let(:aabb) {
+    scope {
+      Parslet.match['ab'].capture(:f) >> dynamic { |s,c| str(c.captures[:f]) }
+    }
+  }
+  it "keeps values of captures outside" do
+    captures[:f] = 'old_value'
+    inject 'aa', aabb
+    captures[:f].should == 'old_value'
+  end
+end

data/spec/parslet/atoms/sequence_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Sequence do
+  include Parslet
+  
+  let(:sequence) { described_class.new }
+  
+  describe '>> shortcut' do
+    let(:sequence) { str('a') >> str('b') }
+    
+    context "when chained with different atoms" do
+      before(:each) { 
+        # Chain something else to the sequence parslet. If it modifies the
+        # parslet atom in place, we'll notice: 
+        
+        sequence >> str('d')
+      }
+      let!(:chained) { sequence >> str('c') }
+      
+      
+      it "is side-effect free" do
+        chained.should parse('abc')
+        chained.should_not parse('abdc')
+      end 
+    end
+    
+  end
+end

data/spec/parslet/atoms/str_spec.rb

@@ -0,0 +1,15 @@
+# Encoding: UTF-8
+
+require 'spec_helper'
+
+describe Parslet::Atoms::Str do
+  def str(s)
+    described_class.new(s)
+  end
+  
+  describe 'regression #1: multibyte characters' do
+    it "parses successfully (length check works)" do
+      str('あああ').should parse('あああ')
+    end 
+  end
+end

data/spec/parslet/atoms/visitor_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Parslet::Atoms do
+  include Parslet
+  let(:visitor) { double(:visitor) }
+
+  describe Parslet::Atoms::Str do
+    let(:parslet) { str('foo') }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_str).with('foo').once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Re do
+    let(:parslet) { Parslet.match['abc'] }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_re).with('[abc]').once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Sequence do
+    let(:parslet) { str('a') >> str('b') }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_sequence).with(Array).once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Repetition do
+    let(:parslet) { str('a').repeat(1, 2) }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_repetition).with(:repetition, 1, 2, Parslet::Atoms::Base).once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Alternative do
+    let(:parslet) { str('a') | str('b') }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_alternative).with(Array).once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Named do
+    let(:parslet) { str('a').as(:a) }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_named).with(:a, Parslet::Atoms::Base).once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Entity do
+    let(:parslet) { Parslet::Atoms::Entity.new('foo', &-> {}) }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_entity).with('foo', Proc).once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe Parslet::Atoms::Lookahead do
+    let(:parslet) { str('a').absent? }
+
+    it 'calls back visitor' do
+      expect(visitor).to receive(:visit_lookahead).with(false, Parslet::Atoms::Base).once
+
+      parslet.accept(visitor)
+    end
+  end
+
+  describe '< Parslet::Parser' do
+    let(:parslet) do
+      Class.new(Parslet::Parser) do
+        rule(:test_rule) { str('test') }
+        root(:test_rule)
+      end.new
+    end
+
+    it 'calls back to visitor' do
+      expect(visitor).to receive(:visit_parser).with(Parslet::Atoms::Base).once
+
+      parslet.accept(visitor)
+    end
+  end
+end