parslet 1.7.0 → 1.7.1

data/spec/parslet/convenience_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'parslet/convenience' do
+  require 'parslet/convenience'
+  include Parslet
+  
+  class FooParser < Parslet::Parser
+    rule(:foo) { str('foo') }
+    root(:foo)
+  end
+  
+  describe 'parse_with_debug' do
+    let(:parser) { flexmock FooParser.new }
+    context 'internal' do
+      before(:each) do
+        # Suppress output.
+        #
+        parser.should_receive(:puts)
+      end
+      it 'should exist' do
+        lambda { parser.parse_with_debug('anything') }.should_not raise_error
+      end
+      it 'should catch ParseFailed exceptions' do
+        lambda { parser.parse_with_debug('bar') }.should_not raise_error
+      end
+      it 'should parse correct input like #parse' do
+        lambda { parser.parse_with_debug('foo') }.should_not raise_error
+      end
+    end
+    context 'output' do
+      it 'should puts once for tree output' do
+        parser.should_receive(:puts).once
+        
+        parser.parse_with_debug('incorrect')
+      end
+      it "should puts once for the error on unconsumed input" do
+        parser.should_receive(:puts).once
+
+        parser.parse_with_debug('foobar')
+      end 
+    end
+    
+    it "should work for all parslets" do
+      str('foo').parse_with_debug('foo')
+      match['bar'].parse_with_debug('a')
+    end 
+  end
+end

data/spec/parslet/error_reporter/contextual_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Parslet::ErrorReporter::Contextual do
+
+  let(:reporter) { described_class.new }
+  let(:fake_source) { flexmock('source') }
+  let(:fake_atom) { flexmock('atom') }
+  let(:fake_cause) { flexmock('cause') }
+
+  describe '#err' do
+    before(:each) { fake_source.should_receive(
+      :pos => 13,
+      :line_and_column => [1,1]) }
+
+    it "returns the deepest cause" do
+      flexmock(reporter).
+        should_receive(:deepest).and_return(:deepest)
+      reporter.err('parslet', fake_source, 'message').
+        should == :deepest
+    end
+  end
+  describe '#err_at' do
+    before(:each) { fake_source.should_receive(
+      :pos => 13,
+      :line_and_column => [1,1]) }
+
+    it "returns the deepest cause" do
+      flexmock(reporter).
+        should_receive(:deepest).and_return(:deepest)
+      reporter.err('parslet', fake_source, 'message', 13).
+        should == :deepest
+    end
+  end
+  describe '#deepest(cause)' do
+    def fake_cause(pos=13, children=nil)
+      flexmock('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(:each) {
+        reporter.deepest(previous) }
+
+      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(:each) {
+        reporter.deepest(previous) }
+
+      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(:each) {
+        reporter.deepest(fake_cause) }
+
+      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(:each) { fake_source.should_receive(
+      :pos => Parslet::Position.new('source', 13),
+      :line_and_column => [1,1]) }
+
+    it "resets deepest cause on success of sibling expression" do
+      flexmock(reporter).
+        should_receive(:deepest).and_return(:deepest)
+      reporter.err('parslet', fake_source, 'message').
+        should == :deepest
+      flexmock(reporter).
+        should_receive(:reset).once
+      reporter.succ(fake_source)
+    end
+  end
+
+  describe 'label' do
+    before(:each) { fake_source.should_receive(
+      :pos => Parslet::Position.new('source', 13),
+      :line_and_column => [1,1]) }
+
+    it "sets label if atom has one" do
+      fake_atom.should_receive(:label).once.and_return('label')
+      fake_cause.should_receive(:set_label).once
+      flexmock(reporter).
+        should_receive(:deepest).and_return(fake_cause)
+      reporter.err(fake_atom, fake_source, 'message').
+        should == fake_cause
+    end
+
+    it 'does not set label if atom does not have one' do
+      flexmock(reporter).
+        should_receive(:deepest).and_return(:deepest)
+      fake_atom.should_receive(:update_label).never
+      reporter.err(fake_atom, fake_source, 'message').
+        should == :deepest
+    end
+  end
+
+end

data/spec/parslet/error_reporter/deepest_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Parslet::ErrorReporter::Deepest do
+  let(:reporter) { described_class.new }
+  let(:fake_source) { flexmock('source') }
+  
+  describe '#err' do
+    before(:each) { fake_source.should_receive(
+      :pos => 13, 
+      :line_and_column => [1,1]) }
+    
+    it "returns the deepest cause" do
+      flexmock(reporter).
+        should_receive(:deepest).and_return(:deepest)
+      reporter.err('parslet', fake_source, 'message').
+        should == :deepest
+    end 
+  end
+  describe '#err_at' do
+    before(:each) { fake_source.should_receive(
+      :pos => 13, 
+      :line_and_column => [1,1]) }
+
+    it "returns the deepest cause" do
+      flexmock(reporter).
+        should_receive(:deepest).and_return(:deepest)
+      reporter.err('parslet', fake_source, 'message', 13).
+        should == :deepest
+    end
+  end
+  describe '#deepest(cause)' do
+    def fake_cause(pos=13, children=nil)
+      flexmock('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(:each) { 
+        reporter.deepest(previous) }
+      
+      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(:each) { 
+        reporter.deepest(previous) }
+        
+      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(:each) { 
+        reporter.deepest(fake_cause) }
+      
+      it "stores the cause as deepest" do
+        deeper = fake_cause(14)
+        reporter.deepest(deeper)
+        reporter.deepest_cause.should == deeper
+      end
+    end
+  end
+end

data/spec/parslet/error_reporter/tree_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+require 'parslet/error_reporter'
+
+describe Parslet::ErrorReporter::Tree do
+  
+end

data/spec/parslet/export_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Parslet::Parser, "exporting to other lingos" do
+  class MiniLisp < Parslet::Parser
+    root :expression
+    rule(:expression) {
+      space? >> str('(') >> space? >> body >> str(')')
+    }
+    
+    rule(:body) {
+      (expression | identifier | float | integer | string).repeat.as(:exp)
+    }
+    
+    rule(:space) {
+      match('\s').repeat(1)
+    }
+    rule(:space?) {
+      space.maybe
+    }
+    
+    rule(:identifier) { 
+      (match('[a-zA-Z=*]') >> match('[a-zA-Z=*_]').repeat).as(:identifier) >> space?
+    }
+    
+    rule(:float) { 
+      (
+        integer >> (
+          str('.') >> match('[0-9]').repeat(1) |
+          str('e') >> match('[0-9]').repeat(1)
+        ).as(:e)
+      ).as(:float) >> space?
+    }
+    
+    rule(:integer) {
+      ((str('+') | str('-')).maybe >> match("[0-9]").repeat(1)).as(:integer) >> space?
+    }
+    
+    rule(:string) {
+      str('"') >> (
+        str('\\') >> any |
+        str('"').absent? >> any 
+      ).repeat.as(:string) >> str('"') >> space?
+    }
+  end
+
+  # I only update the files once I've verified the new syntax to work with 
+  # the respective tools. This is more an acceptance test than a real spec. 
+
+  describe "<- #to_citrus" do
+    let(:citrus) { File.read(
+      File.join(File.dirname(__FILE__), 'minilisp.citrus'))
+    }
+    it "should be valid citrus syntax" do
+      # puts MiniLisp.new.to_citrus
+      MiniLisp.new.to_citrus.should == citrus 
+    end 
+  end
+  describe "<- #to_treetop" do
+    let(:treetop) { File.read(
+      File.join(File.dirname(__FILE__), 'minilisp.tt'))
+    }
+    it "should be valid treetop syntax" do
+      # puts MiniLisp.new.to_treetop
+      MiniLisp.new.to_treetop.should == treetop
+    end 
+  end
+end

data/spec/parslet/expression/treetop_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+require 'parslet'
+
+describe Parslet::Expression::Treetop do
+  include Parslet
+
+  describe "positive samples" do
+    [ # pattern             # input
+      "'abc'",              'abc', 
+      "...",                'abc', 
+      "[1-4]",              '3',
+      
+      "'abc'?",             'abc', 
+      "'abc'?",             '', 
+      
+      "('abc')",            'abc', 
+      
+      "'a' 'b'",            'ab', 
+      "'a' ('b')",          'ab', 
+      
+      "'a' / 'b'",          'a', 
+      "'a' / 'b'",          'b', 
+      
+      "'a'*",               'aaa', 
+      "'a'*",               '', 
+
+      "'a'+",               'aa', 
+      "'a'+",               'a', 
+      
+      "'a'{1,2}",           'a',
+      "'a'{1,2}",           'aa',
+
+      "'a'{1,}",            'a',
+      "'a'{1,}",            'aa',
+
+      "'a'{,2}",            '',
+      "'a'{,2}",            'a',
+      "'a'{,2}",            'aa',
+    ].each_slice(2) do |pattern, input|
+      context "exp(#{pattern.inspect})" do
+        let(:parslet) { exp(pattern) }
+        subject { parslet }
+        it { should parse(input) }
+        context "string representation" do
+          subject { exp(parslet.to_s) }
+          it { should parse(input, :trace => true) }
+        end
+      end
+    end
+  end
+  describe "negative samples" do
+    [ # pattern             # input
+      "'abc'",              'cba', 
+      "[1-4]",              '5',
+      
+      "'a' / 'b'",          'c', 
+      
+      "'a'+",               '',
+      
+      "'a'{1,2}",           '',
+      "'a'{1,2}",           'aaa',
+      
+      "'a'{1,}",            '',
+
+      "'a'{,2}",            'aaa',
+    ].each_slice(2) do |pattern, input|
+      context "exp(#{pattern.inspect})" do
+        subject { exp(pattern) }
+        it { should_not parse(input) }
+      end
+    end
+  end
+end

data/spec/parslet/minilisp.citrus

@@ -0,0 +1,29 @@
+grammar MiniLisp
+  rule root
+    (expression)
+  end
+  rule expression
+    ((space_p) "(" (space_p) (body) ")")
+  end
+  rule space_p
+    (space)0*1
+  end
+  rule body
+    ((expression) | (identifier) | (float) | (integer) | (string))0*
+  end
+  rule space
+    \s1*
+  end
+  rule identifier
+    (([a-zA-Z=*] [a-zA-Z=*_]0*) (space_p))
+  end
+  rule float
+    (((integer) (("." [0-9]1*) | ("e" [0-9]1*))) (space_p))
+  end
+  rule integer
+    ((("+" | "-")0*1 [0-9]1*) (space_p))
+  end
+  rule string
+    ("\"" (("\\" .) | (!"\"" .))0* "\"" (space_p))
+  end
+end

data/spec/parslet/minilisp.tt

@@ -0,0 +1,29 @@
+grammar MiniLisp
+  rule root
+    (expression)
+  end
+  rule expression
+    ((space_p) "(" (space_p) (body) ")")
+  end
+  rule space_p
+    (space)0..1
+  end
+  rule body
+    ((expression) / (identifier) / (float) / (integer) / (string))0..
+  end
+  rule space
+    \s1..
+  end
+  rule identifier
+    (([a-zA-Z=*] [a-zA-Z=*_]0..) (space_p))
+  end
+  rule float
+    (((integer) (("." [0-9]1..) / ("e" [0-9]1..))) (space_p))
+  end
+  rule integer
+    ((("+" / "-")0..1 [0-9]1..) (space_p))
+  end
+  rule string
+    ("\"" (("\\" .) / (!"\"" .))0.. "\"" (space_p))
+  end
+end