parslet 1.7.0 → 1.7.1

data/spec/parslet/parser_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Parslet::Parser do
+  include Parslet
+  class FooParser < Parslet::Parser
+    rule(:foo) { str('foo') }
+    root(:foo)
+  end
+  
+  describe "<- .root" do
+    parser = Class.new(Parslet::Parser)
+    parser.root :root_parslet
+    
+    it "should have defined a 'root' method, returning the root" do
+      parser_instance = parser.new
+      flexmock(parser_instance).should_receive(:root_parslet => :answer)
+      
+      parser_instance.root.should == :answer
+    end 
+  end
+  it "should parse 'foo'" do
+    FooParser.new.parse('foo').should == 'foo'
+  end 
+  context "composition" do
+    let(:parser) { FooParser.new }
+    it "should allow concatenation" do
+      composite = parser >> str('bar')
+      composite.should parse('foobar')
+    end
+  end
+end

data/spec/parslet/parslet_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Parslet do
+  include Parslet
+  
+  describe Parslet::ParseFailed do
+    it "should be caught by an empty rescue" do
+      begin
+        raise Parslet::ParseFailed
+      rescue
+        # Success! Ignore this.
+      end
+    end 
+  end
+  describe "<- .rule" do
+    # Rules define methods. This can be easily tested by defining them right 
+    # here. 
+    context "empty rule" do
+      rule(:empty) { }
+      
+      it "should raise a NotImplementedError" do
+        lambda {
+          empty.parslet
+        }.should raise_error(NotImplementedError)
+      end 
+    end
+    
+    context "containing 'any'" do
+      rule(:any_rule) { any }
+      subject { any_rule }
+      
+      it { should be_a Parslet::Atoms::Entity }
+      it "should memoize the returned instance" do
+        any_rule.object_id.should == any_rule.object_id
+      end 
+    end
+  end
+end

data/spec/parslet/pattern_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+
+require 'parslet'
+
+describe Parslet::Pattern do
+  include Parslet
+  
+  # These two factory methods help make the specs more robust to interface
+  # changes. They also help to label trees (t) and patterns (p).
+  def p(pattern)
+    Parslet::Pattern.new(pattern)
+  end
+  def t(obj)
+    obj
+  end
+  
+  # Tries to match pattern to the tree, and verifies the bindings hash. Don't
+  # use this for new examples.
+  #
+  RSpec::Matchers.define :match_with_bind do |pattern, exp_bindings|
+    unless respond_to?(:failure_message)
+      alias_method :failure_message_for_should, :failure_message
+    end
+    
+    failure_message do |tree|
+      "expected #{pattern.inspect} to match #{tree.inspect}, but didn't. (block wasn't called or not correctly)"
+    end
+    match do |tree|
+      bindings = Parslet::Pattern.new(pattern).match(tree)
+      bindings && bindings == exp_bindings
+    end
+  end
+
+  # This is the more modern version of verifying a match: (uses 'exp'
+  # implicitly). Checks for a match of pattern in +exp+ and yields the
+  # matched variables.
+  #
+  def with_match_locals(pattern, &block) 
+    bindings = p(pattern).match(exp)
+    bindings.should_not be_nil
+    
+    block.call(bindings) if block
+  end
+  
+  # Can't use #match here, so I went to the Thesaurus.
+  #
+  RSpec::Matchers.define :detect do |pattern|
+    match do |tree|
+      bindings = Parslet::Pattern.new(pattern).match(tree)
+
+      bindings ? true : false
+    end
+  end
+  
+  describe "<- #match" do
+    context "injecting bindings" do
+      let(:pattern) { p(simple(:x)) }
+      
+      it "should not modify the original bindings hash" do
+        h = {}
+        b=pattern.match('a', h)
+        h.size.should == 0
+        b.size.should == 1
+      end
+      it "should return nil when no match succeeds" do
+        pattern.match([], :foo => :bar).should be_nil
+      end
+      context "when matching simple(:x) against 'a'" do
+        let(:bindings) { pattern.match(t('a'), :foo => :bar) }
+        
+        before(:each) { bindings.should_not be_nil }
+        it "should return the injected bindings" do
+          bindings[:foo].should == :bar
+        end
+        it "should return the new bindings" do  
+          bindings[:x].should == 'a'
+        end
+      end
+    end
+    context "simple strings" do
+      let(:exp) { 'aaaa' }
+
+      it "should match simple strings" do
+        exp.should match_with_bind(simple(:x), :x => 'aaaa')
+      end 
+    end
+    context "simple hash {:a => 'b'}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t(:a => 'b')
+      end
+
+      it "should not match {:a => simple(:x), :b => simple(:y)}" do
+        exp.should_not detect(:a => simple(:x), :b => simple(:y))
+      end
+      it "should match {:a => simple(:x)}, binding 'x' to the first argument" do
+        exp.should match_with_bind({:a => simple(:x)}, :x => 'b')
+      end 
+      it "should match {:a => 'b'} with no binds" do
+        exp.should match_with_bind({:a => 'b'}, {})
+      end 
+    end
+    context "a more complex hash {:a => {:b => 'c'}}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t(:a => {:b => 'c'})
+      end
+      
+      it "should match wholly with {:a => {:b => simple(:x)}}" do
+        exp.should match_with_bind({:a => {:b => simple(:x)}}, :x => 'c')
+      end
+      it "should match wholly with {:a => subtree(:t)}" do
+        with_match_locals(:a => subtree(:t)) do |dict|
+          dict[:t].should == {:b => 'c'}
+        end
+      end
+      it "should not bind subtrees to variables in {:a => simple(:x)}" do
+        p(:a => simple(:x)).should_not detect(exp)
+      end
+    end
+    context "a more complex hash {:a => 'a', :b => 'b'}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t({:a => 'a', :b => 'b'})
+      end
+
+      it "should not match partially" do
+        Parslet::Pattern.new(:a => simple(:x)).match(exp).should be_nil
+      end 
+      it "should match completely" do
+        exp.should match_with_bind({:a => simple(:x), :b => simple(:y)}, 
+          :x => 'a', 
+          :y => 'b')
+      end 
+    end
+    context "an array of 'a', 'b', 'c'" do
+      let(:exp) { ['a', 'b', 'c'] }
+
+      it "should match all elements at once" do
+        exp.should match_with_bind(
+          [simple(:x), simple(:y), simple(:z)], 
+          :x => 'a', :y => 'b', :z => 'c')
+      end 
+    end
+    context "{:a => 'a', :b => 'b'}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t(:a => 'a', :b => 'b')
+      end
+
+      it "should match both elements simple(:x), simple(:y)" do
+        exp.should match_with_bind(
+          {:a => simple(:x), :b => simple(:y)}, 
+          :x => 'a', :y => 'b')
+      end
+      it "should not match a constrained match (simple(:x) != simple(:y))"  do
+        exp.should_not detect({:a => simple(:x), :b => simple(:x)})
+      end
+    end
+    context "{:a => 'a', :b => 'a'}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t(:a => 'a', :b => 'a')
+      end
+
+      it "should match constrained pattern" do
+        exp.should match_with_bind(
+          {:a => simple(:x), :b => simple(:x)}, 
+          :x => 'a')
+      end
+    end
+    context "{:sub1 => {:a => 'a'}, :sub2 => {:a => 'a'}}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t({
+          :sub1 => {:a => 'a'}, 
+          :sub2 => {:a => 'a'} 
+        })
+      end
+
+      it "should verify constraints over several subtrees" do
+        exp.should match_with_bind({
+          :sub1 => {:a => simple(:x)}, 
+          :sub2 => {:a => simple(:x)} 
+        }, :x => 'a')
+      end
+      it "should return both bind variables simple(:x), simple(:y)" do
+        exp.should match_with_bind({
+          :sub1 => {:a => simple(:x)}, 
+          :sub2 => {:a => simple(:y)} 
+        }, :x => 'a', :y => 'a')
+      end  
+    end
+    context "{:sub1 => {:a => 'a'}, :sub2 => {:a => 'b'}}" do
+      attr_reader :exp
+      before(:each) do
+        @exp = t({
+          :sub1 => {:a => 'a'}, 
+          :sub2 => {:a => 'b'} 
+        })
+      end
+
+      it "should verify constraints over several subtrees" do
+        exp.should_not match_with_bind({
+          :sub1 => {:a => simple(:x)}, 
+          :sub2 => {:a => simple(:x)} 
+        }, :x => 'a')
+      end
+      it "should return both bind variables simple(:x), simple(:y)" do
+        exp.should match_with_bind({
+          :sub1 => {:a => simple(:x)}, 
+          :sub2 => {:a => simple(:y)} 
+        }, :x => 'a', :y => 'b')
+      end  
+    end
+    context "[{:a => 'x'}, {:a => 'y'}]" do
+      attr_reader :exp  
+      before(:each) do
+        @exp = t([{:a => 'x'}, {:a => 'y'}])
+      end
+      
+      it "should not match sequence(:x) (as a whole)" do
+        exp.should_not detect(sequence(:x))
+      end
+    end
+    context "['x', 'y', 'z']" do
+      attr_reader :exp  
+      before(:each) do
+        @exp = t(['x', 'y', 'z'])
+      end
+
+      it "should match [simple(:x), simple(:y), simple(:z)]" do
+        with_match_locals([simple(:x), simple(:y), simple(:z)]) do |dict|
+          dict[:x].should == 'x'
+          dict[:y].should == 'y'
+          dict[:z].should == 'z'
+        end
+      end
+      it "should match %w(x y z)" do
+        exp.should match_with_bind(%w(x y z), { })
+      end 
+      it "should not match [simple(:x), simple(:y), simple(:x)]" do
+        exp.should_not detect([simple(:x), simple(:y), simple(:x)])
+      end
+      it "should not match [simple(:x), simple(:y)]" do
+        exp.should_not detect([simple(:x), simple(:y), simple(:x)])
+      end
+      it "should match sequence(:x) (as array)" do
+        exp.should match_with_bind(sequence(:x), :x => ['x', 'y', 'z'])
+      end
+    end
+    context "{:a => [1,2,3]}" do
+      attr_reader :exp  
+      before(:each) do
+        @exp = t(:a => [1,2,3])
+      end
+
+      it "should match :a => sequence(:x) (binding x to the whole array)" do
+        exp.should match_with_bind({:a => sequence(:x)}, {:x => [1,2,3]})
+      end
+    end
+    context "with differently ordered hashes" do
+      it "should still match" do
+        t(:a => 'a', :b => 'b').should detect(:a => 'a', :b => 'b')
+        t(:a => 'a', :b => 'b').should detect(:b => 'b', :a => 'a')
+
+        t(:b => 'b', :a => 'a').should detect(:b => 'b', :a => 'a')
+        t(:b => 'b', :a => 'a').should detect(:a => 'a', :b => 'b')
+      end 
+    end
+  end
+end

data/spec/parslet/position_spec.rb

@@ -0,0 +1,14 @@
+# Encoding: UTF-8
+
+require 'spec_helper'
+
+describe Parslet::Position do
+  slet(:position) { described_class.new('öäüö', 4) }
+
+  it 'should have a charpos of 2' do
+    position.charpos.should == 2
+  end
+  it 'should have a bytepos of 4' do
+    position.bytepos.should == 4
+  end
+end

data/spec/parslet/rig/rspec_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'parslet/rig/rspec'
+
+describe 'rspec integration' do
+  include Parslet
+  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 Parslet
+
+  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/parslet/scope_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Parslet::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(Parslet::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