parslet 1.7.0 → 1.7.1

data/spec/acceptance/repetition_and_maybe_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "Tree output" do
+  extend Parslet
+
+  def self.hash_examples(h)
+    h.each do |atom, expected|
+      it "should convert #{atom} to #{expected.inspect}" do
+        atom.parse(input).should == expected
+      end
+    end
+  end
+
+  context "when parsing the empty string" do
+    let(:input) { '' }
+    hash_examples( 
+      # No naming 
+      str('a').maybe              => '', 
+      str('a').repeat             => '',
+      
+      # Named contents: maybe yields nil
+      str('a').maybe.as(:f)       => {:f => nil},
+      str('a').repeat.as(:f)      => {:f => []}, 
+      
+      # Contents that aren't simple strings
+      (str('a') >> str('b')).maybe.as(:f)     => {:f => nil},
+      (str('a') >> str('b')).repeat.as(:f)    => {:f => []}, 
+      
+      # The other way around: Contents would be tagged, but nil result isn't
+      (str('a') >> str('b')).as(:f).maybe     => '',
+      (str('a') >> str('b')).as(:f).repeat    => ''
+    )
+  end
+  
+  context "when parsing 'aa'" do
+    let(:input) { 'aa' }
+    hash_examples(
+      # since they're not named, repetitions get merged together.
+      str('a').as(:a).repeat >> str('a').as(:a).repeat => [{:a=>'a'},{:a=>'a'}]
+    )
+  end
+end

data/spec/acceptance/unconsumed_input_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe "Unconsumed input:" do
+  class RepeatingBlockParser < Parslet::Parser
+    root :expressions
+    rule(:expressions) { expression.repeat }
+    rule(:expression) { str('(') >> aab >> str(')') }
+    rule(:aab) { str('a').repeat(1) >> str('b') }
+  end
+  describe RepeatingBlockParser do
+    let(:parser) { described_class.new }
+    it "throws annotated error" do
+      error = catch_failed_parse { parser.parse('(aaac)') }
+    end
+    it "doesn't error out if prefix is true" do
+      expect {
+        parser.parse('(aaac)', :prefix => true)
+      }.not_to raise_error
+    end
+  end
+end

data/spec/parslet/atom_results_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Result of a Parslet#parse' do
+  include Parslet; extend Parslet
+  
+  describe "regression" do
+    [
+      # Behaviour with maybe-nil
+      [str('foo').maybe >> str('bar'), "bar", "bar"],
+      [str('bar') >> str('foo').maybe, "bar", 'bar'], 
+      
+      # These might be hard to understand; look at the result of 
+      #   str.maybe >> str
+      # and 
+      #   str.maybe >> str first. 
+      [(str('f').maybe >> str('b')).repeat, "bb", "bb"],
+      [(str('b') >> str('f').maybe).repeat, "bb", 'bb'], 
+      
+      [str('a').as(:a) >> (str('b') >> str('c').as(:a)).repeat, 'abc', 
+        [{:a=>'a'}, {:a=>'c'}]], 
+      
+      [str('a').as(:a).repeat >> str('b').as(:b).repeat, 'ab', [{:a=>'a'}, {:b=>'b'}]], 
+      
+      # Repetition behaviour / named vs. unnamed
+      [str('f').repeat, '', ''], 
+      [str('f').repeat.as(:f), '', {:f => []}],
+
+      # Maybe behaviour / named vs. unnamed
+      [str('f').maybe, '', ''], 
+      [str('f').maybe.as(:f), '', {:f => nil}],
+    ].each do |parslet, input, result|
+      context "#{parslet.inspect}" do
+        it "should parse \"#{input}\" into \"#{result}\"" do
+          parslet.parse(input).should == result
+        end
+      end
+    end
+  end
+end

data/spec/parslet/atoms/alternative_spec.rb

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

data/spec/parslet/atoms/base_spec.rb

@@ -0,0 +1,126 @@
+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 "should raise NotImplementedError" do
+      lambda {
+        parslet.try(flexmock(: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.
+      #
+      ['a', 'b'], 'ab',                             # S S
+      [['a'], ['b']], ['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 "should equal #{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 "should give 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) { flexmock("source lookalike", 
+        :line_and_column => [1,2], 
+        :bytepos => 1, 
+        :chars_left => 0) }
+      
+      it "should not rewrap in a source" do
+        flexmock(Parslet::Source).
+          should_receive(:new => :source_created).never
+        
+        begin
+          parslet.parse(source) 
+        rescue NotImplementedError
+        end
+      end 
+    end
+  end
+  
+  context "when the parse fails, the exception" do
+    it "should contain a string" do
+      begin
+        Parslet.str('foo').parse('bar')
+      rescue Parslet::ParseFailed => ex
+        ex.message.should be_kind_of(String)
+      end
+    end 
+  end
+  context "when not all input is consumed" do
+    let(:parslet) { Parslet.str('foo') }
+    
+    it "should raise with a proper error message" do
+      error = catch_failed_parse {
+        parslet.parse('foobar') }
+      
+      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) { flexmock(:reporter) }
+    
+    it "replaces the default reporter" do
+      cause = flexmock(:cause)
+      
+      # Two levels of the parse, calling two different error reporting
+      # methods.
+      reporter.
+        should_receive(:err_at).once
+      reporter.
+        should_receive(:err => cause).once
+      reporter.
+        should_receive(:succ).once
+      
+      # The final cause will be sent the #raise method.
+      cause.
+        should_receive(:raise).once.and_throw(:raise)
+      
+      catch(:raise) {
+        parslet.parse('testung', :reporter => reporter)
+        
+        fail "NEVER REACHED"
+      }
+    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,25 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::DSL do
+  describe "deprecated methods" do
+    let(:parslet) { Parslet.str('foo') }
+    describe "<- #absnt?" do
+      slet(:absnt) { parslet.absnt? }
+      it '#bound_parslet' do
+        absnt.bound_parslet.should == parslet
+      end
+      it 'should be a negative lookahead' do
+        absnt.positive.should == false
+      end
+    end
+    describe "<- #prsnt?" do
+      slet(:prsnt) { parslet.prsnt? }
+      it '#bound_parslet' do
+        prsnt.bound_parslet.should == parslet
+      end
+      it 'should be a positive lookahead' do
+        prsnt.positive.should == true
+      end
+    end
+  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/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
+      match('[a]').should be_a(Parslet::Atoms::Re)
+    end 
+    it "should allow match[str] form" do
+      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