rattler 0.3.0 → 0.4.0

data/spec/rattler/runtime/shared_parser_examples.rb

@@ -2,59 +2,92 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 shared_examples_for 'a recursive descent parser' do
   include RuntimeParserSpecHelper
-  
+
+  describe '#parse' do
+
+    let(:grammar) { define_grammar do
+      rule(:word) { match(/\w+/) }
+    end }
+
+    it 'applies the start rule to the source' do
+      parsing('Hello World!').should result_in('Hello').at(5)
+    end
+
+  end
+end
+
+shared_examples_for 'a generated recursive descent parser' do
+  include RuntimeParserSpecHelper
+
+  it_behaves_like 'a recursive descent parser'
+
+  let(:parser_class) do
+    Rattler::BackEnd::Compiler.compile_parser described_class, grammar
+  end
+
   describe '#match' do
-    
+
+    let(:grammar) { define_grammar do
+      rule(:word) { match(/\w+/) }
+    end }
+
     it 'dispatches to the correct match method' do
-      given_rules { rule(:foo) { match(/\w+/) } }.
-      parsing('Hello World!').as(:foo).should result_in('Hello').at(5)
+      matching('Hello World!').as(:word).should result_in('Hello').at(5)
     end
-    
+
     it 'registers parse errors' do
-      given_rules { rule(:foo) { match(/d+/) } }.
-      parsing('Hello World!').as(:foo).
-      should fail.at(0).with_message('foo expected')
+      matching('@').as(:word).
+      should fail.at(0).with_message('word expected')
     end
-    
-    it 'supports recursive rules' do
-      given_rules do
+
+    context 'given recursive rules' do
+
+      let(:grammar) { define_grammar do
         rule :a do
           ( match(/\d/) & match(:a) \
           | match(/\d/)             )
         end
-      end.
-      parsing('451a').as(:a).should result_in(['4', ['5', '1']]).at(3)
+      end }
+
+      it 'applies the rules recursively' do
+        matching('1234abc').as(:a).should result_in(['1', ['2', ['3', '4']]]).at(4)
+      end
     end
-    
   end
-  
+
 end
 
-shared_examples_for 'a packrat parser' do
+shared_examples_for 'a generated packrat parser' do
   include RuntimeParserSpecHelper
 
-  it_behaves_like 'a recursive descent parser'
+  it_behaves_like 'a generated recursive descent parser'
+
+  let(:parser_class) do
+    Rattler::BackEnd::Compiler.compile_parser described_class, grammar
+  end
 
   describe '#match' do
 
-    it 'memoizes parse results' do
-      example = given_rules do
+    context 'given recursive rules' do
+
+      let(:grammar) { define_grammar do
         rule :a do
           ( match(:b) & match('a') \
-          | match(:b) & match('b') )
+          | match(:b) & eof )
         end
         rule :b do
-          match('b')
+          match('b') & disallow(:a)
         end
-      end.
-      parsing('bb').as(:a)
-      example.parser.should_receive(:match_b).and_return do
-        example.parser.pos = example.parser.pos + 1
-        'b'
+      end }
+
+      let(:example) { matching('bag').as(:a) }
+
+      it 'memoizes parse results' do
+        example.parser.should_receive(:match_b!).
+          and_return { example.parser.pos += 1; 'b' }
+        example.should result_in(['b', 'a']).at(2)
       end
-      example.should result_in(['b', 'b']).at(2)
     end
-
   end
 
 end

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

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+require 'set'
+
+describe Rattler::Util::GraphViz::NodeBuilder do
+
+  describe '#array_like?' do
+
+    context 'given an array' do
+      it 'returns true' do
+        subject.array_like?(['a']).should be_true
+      end
+    end
+
+    context 'given a hash' do
+      it 'returns true' do
+        subject.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
+      end
+    end
+  end
+
+  describe '#record_like?' do
+
+    context 'given a hash of simple values' do
+      it 'returns true' do
+        subject.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
+      end
+    end
+
+    context 'given an array' do
+      it 'returns false' do
+        subject.record_like?(['a']).should be_false
+      end
+    end
+  end
+
+  describe '#each_child_of' do
+
+    context 'given an array' do
+
+      let(:object) { ['a', 'b', 'c'] }
+
+      it 'iterates over the members' do
+        children = []
+        subject.each_child_of(object) {|_| children << _ }
+        children.should == ['a', 'b', 'c']
+      end
+    end
+
+    context 'given a hash with compound values' do
+
+      let(:object) { {:a => ['a1', 'a2'], :b => 'b'} }
+
+      it 'iterates over the pairs' do
+        children = Set[]
+        subject.each_child_of(object) {|_| children << _ }
+        children.should == Set[[:a, ['a1', 'a2']], [:b, 'b']]
+      end
+    end
+
+    context 'given a hash with simple values' do
+
+      let(:object) { {:a => 'a', :b => 'b'} }
+
+      it 'does nothing' do
+        children = Set[]
+        subject.each_child_of(object) {|_| children << _}
+        children.should be_empty
+      end
+    end
+  end
+
+end

data/spec/rattler/util/node_spec.rb

@@ -3,100 +3,100 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 include Rattler::Util
 
 describe Node do
-  
+
   describe '#children' do
-    
+
     context 'when the Node has children' do
       subject do
         Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar'))
       end
-      
+
       it 'returns the children' do
         subject.children.
           should == [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
       end
     end
-    
+
     context 'when the Node has no children' do
-      
+
       subject { Node.new }
-      
+
       it 'returns an empty array' do
         subject.children.should == []
       end
     end
-    
+
     context 'when the Node has children and attributes' do
       subject do
         Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar'), :foo => 'bar')
       end
-      
+
       it 'returns the children' do
         subject.children.
           should == [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
       end
     end
-    
+
     context 'when the Node has only attributes' do
-      
+
       subject { Node.new(:foo => 'bar', :bar => nil) }
-      
+
       it 'returns an empty array' do
         subject.children.should == []
       end
     end
   end
-  
+
   describe '#attrs' do
     context 'when the Node has attributes' do
-      
+
       subject { Node.new(:foo => 'bar', :bar => nil) }
-      
+
       it 'returns a Hash of the attributes' do
         subject.attrs.should == { :foo => 'bar', :bar => nil }
       end
     end
-    
+
     context 'when the Node has no attributes' do
-      
+
       subject { Node.new }
-      
+
       it 'returns an empty Hash' do
         subject.attrs.should == {}
       end
     end
-    
+
     context 'when the Node has children and attributes' do
       subject do
         Node.new(Node.new(:name => 'foo'), :foo => 'bar', :bar => nil)
       end
-      
+
       it 'returns a Hash of the attributes' do
         subject.attrs.should == { :foo => 'bar', :bar => nil }
       end
     end
-    
+
     context 'when the Node has only children' do
       subject do
         Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar'))
       end
-      
+
       it 'returns an empty Hash' do
         subject.attrs.should == {}
       end
     end
   end
-  
+
   describe '#child' do
     context 'when the Node has children' do
       subject do
         Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar'))
       end
-      
+
       it 'returns the first child' do
         subject.child.should == Node.new(:name => 'foo')
       end
-      
+
       context 'given an index' do
         it 'returns the child at the index' do
           subject.child(0).should == Node.new(:name => 'foo')
@@ -104,63 +104,63 @@ describe Node do
         end
       end
     end
-    
+
     context 'when the Node has no children' do
-      
+
       subject { Node.new }
-      
+
       it 'returns nil' do
         subject.child.should be_nil
       end
     end
   end
-  
+
   describe '#name' do
     context 'when the Node as a name attribute' do
-      
+
       subject { Node.new(:name => 'foo' ) }
-      
+
       it 'uses the name attribute as name' do
         subject.name.should == 'foo'
       end
     end
-    
+
     context 'when the Node has no name attribute' do
-      
+
       subject { Node.new }
-      
+
       it 'uses the class name as name' do
         subject.name.should == 'Rattler::Util::Node'
       end
     end
   end
-  
+
   describe '#[]' do
     context 'when the Node has children' do
       subject do
         Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar'))
       end
-      
+
       context 'given a single index' do
         it 'returns the child at the index' do
           subject[0].should == Node.new(:name => 'foo')
           subject[1].should == Node.new(:name => 'bar')
         end
       end
-      
+
       context 'given a negative index' do
         it 'counts backward from the last child' do
           subject[-1].should == Node.new(:name => 'bar')
           subject[-2].should == Node.new(:name => 'foo')
         end
       end
-      
+
       context 'given an out-of-range index' do
         it 'returns nil' do
           subject[3].should be_nil
         end
       end
-      
+
       context 'given an index and a length' do
         it 'returns an array of children starting at the index' do
           subject[0, 2].should == [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
@@ -168,7 +168,7 @@ describe Node do
           subject[1, 1].should == [Node.new(:name => 'bar')]
         end
       end
-      
+
       context 'given a negative index and a length' do
         it 'counts backward from the last child' do
           subject[-2, 2].should == [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
@@ -176,19 +176,19 @@ describe Node do
           subject[-1, 1].should == [Node.new(:name => 'bar')]
         end
       end
-      
+
       context 'given an out-of-range index and a length' do
         it 'returns nil' do
           subject[3].should be_nil
         end
       end
-      
+
       context 'given an index exactly one past the last child and a length' do
         it 'returns an empty array' do
           subject[2, 2].should == []
         end
       end
-      
+
       context 'given a range' do
         it 'return an array of children indexed by the range' do
           subject[0..1].should == [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
@@ -196,7 +196,7 @@ describe Node do
           subject[1..1].should == [Node.new(:name => 'bar')]
         end
       end
-      
+
       context 'given a range with a negative index' do
         it 'counts backward from the last child' do
           subject[-2..-1].should == [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
@@ -204,13 +204,13 @@ describe Node do
           subject[-1..-1].should == [Node.new(:name => 'bar')]
         end
       end
-      
+
       context 'given a range with an out-of-range index' do
         it 'returns nil' do
           subject[3..3].should be_nil
         end
       end
-      
+
       context 'given a range starting exactly one past the last child' do
         it 'returns an empty array' do
           subject[2..2].should == []
@@ -218,101 +218,128 @@ describe Node do
       end
     end
   end
-  
+
   describe '#count' do
     context 'when the Node has children' do
       subject do
         Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar'))
       end
-      
+
       it 'returns the number of children' do
         subject.count.should == 2
       end
     end
-    
+
     context 'when the Node has no children' do
       subject { Node.new }
-      
+
       it 'returns 0' do
         subject.count.should == 0
       end
     end
   end
-  
+
   describe '#==' do
     subject { Node.new(Node.new(:name => 'foo'), :foo => 'bar') }
-    
+
     context 'given a node with the same children and attributes' do
       it 'returns true' do
         subject.should == Node.new(Node.new(:name => 'foo'), :foo => 'bar')
       end
     end
-    
+
     context 'given a node with different children' do
       it 'returns false' do
         subject.should_not == Node.new(Node.new(:name => 'boo'), :foo => 'bar')
       end
     end
-    
+
     context 'given a node with extra children' do
       it 'returns false' do
         subject.should_not ==
           Node.new(Node.new(:name => 'boo'), Node.new, :foo => 'bar')
       end
     end
-    
+
     context 'given a node with no children' do
       it 'returns false' do
         subject.should_not == Node.new(:foo => 'bar')
       end
     end
-    
+
     context 'given a node with the same children and different attributes' do
       it 'returns false' do
         subject.should_not == Node.new(Node.new(:name => 'foo'), :foo => 'baz')
       end
     end
-    
+
     context 'given a node with the same children and extra attributes' do
       it 'returns false' do
         subject.should_not ==
           Node.new(Node.new(:name => 'foo'), :foo => 'bar', :bar => 'baz')
       end
     end
-    
+
     context 'given a node with the same children but no attributes' do
       it 'returns false' do
         subject.should_not == Node.new(Node.new(:name => 'foo'))
       end
     end
   end
-  
+
+  describe '#each' do
+
+    subject { Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar')) }
+
+    let(:expected_items) do
+      [Node.new(:name => 'foo'), Node.new(:name => 'bar')]
+    end
+
+    it 'iterates over #children' do
+      subject.each {|_| _.should == expected_items.shift }
+    end
+  end
+
+  describe '#with_children' do
+
+    subject { Node.new(Node.new(:name => 'foo'), Node.new(:name => 'bar')) }
+
+    let :new_children do
+      [Node.new(:name => 'boo'), Node.new(:name => 'baz')]
+    end
+
+    it 'returns a new node with the children replaced' do
+      subject.with_children(new_children).should ==
+        Node.new(Node.new(:name => 'boo'), Node.new(:name => 'baz'))
+    end
+  end
+
   describe '#method_missing' do
-    
+
     subject { Node.new(:foo => 'bar', :bar => nil) }
-    
+
     it 'provides accessor methods for attributes' do
       subject.foo.should == 'bar'
       subject.bar.should == nil
     end
   end
-  
+
   describe '#respond_to?' do
-    
+
     subject { Node.new(:foo => 'bar', :bar => nil) }
-    
+
     context 'given an attribute name' do
       it 'returns true' do
         subject.should respond_to(:foo)
         subject.should respond_to(:bar)
       end
     end
-    
+
     context 'given a meaningless name' do
       it 'returns false' do
         subject.should_not respond_to(:fred)
       end
     end
   end
-  
+
 end