rattler 0.5.0 → 0.6.0

data/spec/rattler/parsers/skip_spec.rb

@@ -28,6 +28,27 @@ describe Skip do
     end
   end
 
+  describe '#capturing_decidable?' do
+
+    context 'with a capturing_decidable parser' do
+
+      let(:nested) { Match[/\w+/] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+
+    context 'with a non-capturing_decidable parser' do
+
+      let(:nested) { Apply[:foo] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+  end
+
   describe '#with_ws' do
 
     let(:ws) { Match[/\s*/] }

data/spec/rattler/parsers/super_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Super do
+  include CombinatorParserSpecHelper
+
+  subject { Super[:word] }
+
+  let(:rules) { RuleSet.new(:includes => [included_rules]) }
+
+  let(:included_rules) { RuleSet[Rule[:word, Match[/\w+/]]] }
+
+  describe '#parse' do
+
+    context 'when the inherited rule matches' do
+      it 'succeeds returns the result' do
+        parsing('abc123  ').should result_in('abc123').at(6)
+      end
+    end
+
+    context 'when the inherited rule fails' do
+      it 'fails' do
+        parsing('==').should fail
+      end
+    end
+  end
+
+  describe '#capturing?' do
+    it 'is true' do
+      subject.should be_capturing
+    end
+  end
+
+  describe '#capturing_decidable?' do
+    it 'is false' do
+      subject.should_not be_capturing_decidable
+    end
+  end
+
+  describe '#with_ws' do
+    it 'returns self' do
+      subject.with_ws(Match[/\s*/]).should == subject
+    end
+  end
+
+end

data/spec/rattler/parsers/token_spec.rb

@@ -2,53 +2,72 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Token do
   include CombinatorParserSpecHelper
-  
+
   describe '#parse' do
-    
+
     subject do
       Token[Sequence[Match[/[[:alpha:]]+/], Match[/\=/], Match[/[[:digit:]]+/]]]
     end
-    
+
     context 'when the parser matches' do
       it 'matches returning the entire matched string' do
         parsing('val=42 ').should result_in('val=42').at(6)
       end
     end
-    
+
     context 'when the parser fails' do
       it 'fails' do
         parsing('val=x').should fail
       end
     end
-    
+
     context 'with a non-capturing parser' do
-      
+
       subject { Token[Skip[Match[/\w+/]]] }
-      
+
       context 'when the parser matches' do
         it 'matches returning the entire matched string' do
           parsing('abc123 ').should result_in('abc123').at(6)
         end
       end
     end
-    
+
   end
-  
+
   describe '#capturing?' do
-    
+
     subject { Token[Match[/\w+/]] }
-    
+
     it 'is true' do
       subject.should be_capturing
     end
-    
+
     context 'with a non-capturing parser' do
+
       subject { Token[Skip[Match[/\s*/]]] }
+
       it 'is true' do
         subject.should be_capturing
       end
     end
-    
   end
-  
+
+  describe '#capturing_decidable?' do
+
+    subject { Token[Match[/\w+/]] }
+
+    it 'is true' do
+      subject.should be_capturing_decidable
+    end
+
+    context 'with a non-capturing_decidable parser' do
+
+      subject { Token[Apply[:foo]] }
+
+      it 'is true' do
+        subject.should be_capturing_decidable
+      end
+    end
+  end
+
 end

data/spec/rattler/runtime/extended_packrat_parser_spec.rb

@@ -7,18 +7,20 @@ describe Rattler::Runtime::ExtendedPackratParser do
   it_behaves_like 'a generated packrat parser'
 
   let :parser_class do
-    Rattler::BackEnd::Compiler.compile_parser described_class, grammar
+    Rattler::Compiler.compile_parser described_class, grammar
   end
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   describe '#match' do
 
     context 'given a directly left-recursive rule' do
-      let(:grammar) { define_grammar do
-        rule :a do
+      let(:rules) { [
+        rule(:a) {
           ( match(:a) & match(/\d/) \
           | match(/\d/)             )
-        end
-      end }
+        }
+      ] }
 
       it 'parses correctly' do
         parsing('12345a').should result_in([[[['1', '2'], '3'], '4'], '5']).at(5)
@@ -26,10 +28,10 @@ describe Rattler::Runtime::ExtendedPackratParser do
     end
 
     context 'given indirectly left-recursive rules' do
-      let(:grammar) { define_grammar do
-        rule(:a) { match(:b) | match(/\d/) }
+      let(:rules) { [
+        rule(:a) { match(:b) | match(/\d/) },
         rule(:b) { match(:a) & match(/\d/) }
-      end }
+      ] }
 
       it 'parses correctly' do
         parsing('12345a').should result_in([[[['1', '2'], '3'], '4'], '5']).at(5)

data/spec/rattler/runtime/recursive_descent_parser_spec.rb

@@ -2,5 +2,31 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require File.expand_path(File.dirname(__FILE__) + '/shared_parser_examples')
 
 describe Rattler::Runtime::RecursiveDescentParser do
+
   it_behaves_like 'a generated recursive descent parser'
+
+  describe '.grammar' do
+
+    let(:parser_class) { Class.new(described_class) }
+
+    context 'given a string' do
+
+      before { parser_class.module_eval do
+        grammar <<-G
+          word  <-  @WORD+
+          num   <-  @DIGIT+
+        G
+      end }
+
+      it 'defines rule methods using the grammar syntax' do
+        parser_class.should have_method(:match_word)
+        parser_class.should have_method(:match_num )
+      end
+    end
+  end
+
+  def have_method(rule_name)
+    be_method_defined(rule_name)
+  end
+
 end

data/spec/rattler/runtime/shared_parser_examples.rb

@@ -3,11 +3,13 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 shared_examples_for 'a recursive descent parser' do
   include RuntimeParserSpecHelper
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   describe '#parse' do
 
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:word) { match(/\w+/) }
-    end }
+    ] }
 
     it 'applies the start rule to the source' do
       parsing('Hello World!').should result_in('Hello').at(5)
@@ -22,14 +24,16 @@ shared_examples_for 'a generated recursive descent parser' do
   it_behaves_like 'a recursive descent parser'
 
   let(:parser_class) do
-    Rattler::BackEnd::Compiler.compile_parser described_class, grammar
+    Rattler::Compiler.compile_parser described_class, grammar
   end
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   describe '#match' do
 
-    let(:grammar) { define_grammar do
+    let(:rules) { [
       rule(:word) { match(/\w+/) }
-    end }
+    ] }
 
     it 'dispatches to the correct match method' do
       matching('Hello World!').as(:word).should result_in('Hello').at(5)
@@ -42,12 +46,12 @@ shared_examples_for 'a generated recursive descent parser' do
 
     context 'given recursive rules' do
 
-      let(:grammar) { define_grammar do
-        rule :a do
+      let(:rules) { [
+        rule(:a) {
           ( match(/\d/) & match(:a) \
           | match(/\d/)             )
-        end
-      end }
+        }
+      ] }
 
       it 'applies the rules recursively' do
         matching('1234abc').as(:a).should result_in(['1', ['2', ['3', '4']]]).at(4)
@@ -63,22 +67,24 @@ shared_examples_for 'a generated packrat parser' do
   it_behaves_like 'a generated recursive descent parser'
 
   let(:parser_class) do
-    Rattler::BackEnd::Compiler.compile_parser described_class, grammar
+    Rattler::Compiler.compile_parser described_class, grammar
   end
 
+  let(:grammar) { Rattler::Parsers::Grammar[Rattler::Parsers::RuleSet[*rules]] }
+
   describe '#match' do
 
     context 'given recursive rules' do
 
-      let(:grammar) { define_grammar do
-        rule :a do
+      let(:rules) { [
+        rule(:a) {
           ( match(:b) & match('a') \
           | match(:b) & eof )
-        end
-        rule :b do
+        },
+        rule(:b) {
           match('b') & disallow(:a)
-        end
-      end }
+        }
+      ] }
 
       let(:example) { matching('bag').as(:a) }
 

data/spec/rattler/util/graphviz/node_builder_spec.rb

@@ -3,42 +3,58 @@ require 'set'
 
 describe Rattler::Util::GraphViz::NodeBuilder do
 
+  let(:builder) { Rattler::Util::GraphViz::NodeBuilder }
+
   describe '#node_label' do
 
     context 'given a number' do
       it 'returns a number as a string' do
-        subject.node_label(42).should == '42'
+        builder.node_label(42).should == '42'
       end
     end
 
     context 'given a string' do
-      it 'returns the string surrounded by escaped quotes' do
-        subject.node_label('abc').should == '"abc"'
+      it 'returns the string surrounded by quotes' do
+        builder.node_label('abc').should == '"abc"'
       end
     end
 
     context 'given an unnamed record-like object' do
       it 'returns a record label with the class name' do
-        subject.node_label(Rattler::Util::Node[]).should == '{Rattler::Util::Node}'
+        builder.node_label(Rattler::Util::Node[]).should == '{Rattler::Util::Node}'
       end
     end
 
     context 'given a named record-like object' do
       it 'returns a record label with a name' do
-        subject.node_label(Rattler::Util::Node[{:name => 'IDENT'}]).
+        builder.node_label(Rattler::Util::Node[{:name => 'IDENT'}]).
           should == '{IDENT}'
       end
     end
 
     context 'given an array-like object' do
       it 'returns "[]" escaped' do
-        subject.node_label(['let', 'x', '=', '1']).should == '\\[\\]'
+        builder.node_label(['let', 'x', '=', '1']).should == '\\[\\]'
       end
     end
 
     context 'given a hash with compound values' do
       it 'returns "{}" escaped' do
-        subject.node_label({:a => 'a', :b => ['a1', 'a2']}).should == '\\{\\}'
+        builder.node_label({:a => 'a', :b => ['a1', 'a2']}).should == '\\{\\}'
+      end
+    end
+
+    context 'given a hash with simple values' do
+      it 'returns a record label with the values' do
+        builder.node_label({:a => 'a', :b => 'b'}).should ==
+          '{\\{\\}|{:a|"a"}|{:b|"b"}}'
+      end
+
+      context 'with special characters' do
+        it 'escapes the special characters' do
+          builder.node_label({:a => '<|>\\'}).should ==
+            '{\\{\\}|{:a|"\\<\\|\\>\\\\"}}'
+        end
       end
     end
   end
@@ -47,19 +63,19 @@ describe Rattler::Util::GraphViz::NodeBuilder do
 
     context 'given an array' do
       it 'returns true' do
-        subject.array_like?(['a']).should be_true
+        builder.array_like?(['a']).should be_true
       end
     end
 
     context 'given a simple hash' do
       it 'returns true' do
-        subject.array_like?({:a => 'a'}).should be_true
+        builder.array_like?({:a => 'a'}).should be_true
       end
     end
 
     context 'given a string' do
       it 'returns false' do
-        subject.array_like?('a').should be_false
+        builder.array_like?('a').should be_false
       end
     end
   end
@@ -68,24 +84,24 @@ describe Rattler::Util::GraphViz::NodeBuilder do
 
     context 'given a hash of simple values' do
       it 'returns true' do
-        subject.record_like?({:a => 'a', :b => 'b'}).should be_true
+        builder.record_like?({:a => 'a', :b => 'b'}).should be_true
       end
     end
 
     context 'given a hash with compound values' do
       it 'returns false' do
-        subject.record_like?({:a => ['a1', 'a2'], :b => 'b'}).should be_false
+        builder.record_like?({:a => ['a1', 'a2'], :b => 'b'}).should be_false
       end
     end
 
     context 'given an array' do
       it 'returns false' do
-        subject.record_like?(['a']).should be_false
+        builder.record_like?(['a']).should be_false
       end
     end
   end
 
-  describe '#each_child_of' do
+  describe '#each_child_node_of' do
 
     context 'given an array' do
 
@@ -93,7 +109,7 @@ describe Rattler::Util::GraphViz::NodeBuilder do
 
       it 'iterates over the members' do
         children = []
-        subject.each_child_of(object) {|_| children << _ }
+        builder.each_child_node_of(object) {|_| children << _ }
         children.should == ['a', 'b', 'c']
       end
     end
@@ -104,7 +120,7 @@ describe Rattler::Util::GraphViz::NodeBuilder do
 
       it 'iterates over the pairs yielding Mappings' do
         children = Set[]
-        subject.each_child_of(object) {|_| children << _ }
+        builder.each_child_node_of(object) {|_| children << _ }
         children.should have(2).mappings
       end
     end
@@ -115,7 +131,7 @@ describe Rattler::Util::GraphViz::NodeBuilder do
 
       it 'does nothing' do
         children = Set[]
-        subject.each_child_of(object) {|_| children << _}
+        builder.each_child_node_of(object) {|_| children << _}
         children.should be_empty
       end
     end