treetop 0.1.0 → 1.0.0

data/test/compiler/grammar_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class GrammarTest < CompilerTestCase
+  module Bar
+  end
+
+  testing_grammar %{
+    grammar Foo
+      include Bar
+    
+      rule foo
+        bar / baz
+      end
+      
+      rule bar
+        'bar' 'bar'
+      end
+      
+      rule baz
+        'baz' 'baz'
+      end
+    end
+  }
+  
+  it "parses matching input" do
+    parse('barbar').should be_success
+    parse('bazbaz').should be_success
+  end
+  
+  it "mixes in included modules" do
+    Foo.ancestors.should include(Bar)
+  end
+end

data/test/compiler/nonterminal_symbol_test.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+describe "A nonterminal symbol", :extend => CompilerTestCase do
+  testing_expression 'foo'
+  
+  parser_class_under_test.class_eval do
+    def _nt_foo
+      '_nt_foo called'
+    end
+  end
+  
+  it "compiles to a message send" do
+    parse('').should == '_nt_foo called'
+  end
+end

data/test/compiler/not_predicate_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+describe "A !-predicated terminal symbol", :extend => CompilerTestCase do
+  testing_expression '!"foo"'
+  
+  it "fails to parse input matching the terminal symbol" do
+    parse('foo').should be_failure
+  end
+end
+
+describe "A sequence of a terminal and an and another !-predicated terminal", :extend => CompilerTestCase do
+  testing_expression '"foo" !"bar"'
+
+  it "fails to match input matching both terminals" do
+    parse('foobar').should be_failure
+  end
+  
+  it "successfully parses input matching the first terminal and not the second, with the failure of the second as a nested failure" do
+    parse('foo') do |result|
+      result.should be_success
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures[0]
+      nested_failure.index.should == 3
+      nested_failure.expected_string.should == 'bar'
+    end
+  end
+end
+
+describe "A !-predicated sequence", :extend => CompilerTestCase do
+  testing_expression '!("a" "b" "c")'
+
+  it "fails to parse matching input" do
+    parse('abc').should be_failure
+  end
+end

data/test/compiler/one_or_more_test.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class OneOrMoreOfTerminalTest < CompilerTestCase
+  testing_expression '"foo"+ <Foo> { def a_method; end }'
+
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  it "fails to parse epsilon with a nested failure" do
+    parse('') do |result|
+      result.should be_failure
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 0
+      nested_failure.expected_string.should == 'foo'
+    end
+  end
+  
+  it "successfully parses two of that terminal in a row, returning an instance of the declared node class with a nested failure representing the third attempt" do
+    parse("foofoo") do |result|
+      result.should be_success
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 6
+      nested_failure.expected_string.should == 'foo'
+    end
+  end
+end

data/test/compiler/optional_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+describe "An optional terminal symbol", :extend => CompilerTestCase do
+  testing_expression '"foo"?'
+  
+  it "parses input matching the terminal" do
+    parse('foo').should be_success
+  end
+  
+  it "parses epsilon, with a nested failure" do
+    parse('') do |result|
+      result.should be_success
+      result.interval.should == (0...0)
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 0
+      nested_failure.expected_string.should == 'foo'
+    end
+  end
+  
+  it "parses input not matching the terminal, returning an epsilon result with a nested failure" do
+    parse('bar') do |result|
+      result.should be_success
+      result.interval.should == (0...0)
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 0
+      nested_failure.expected_string.should == 'foo'
+    end
+  end
+end
+

data/test/compiler/parsing_rule_test.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ParsingRuleTest < CompilerTestCase
+
+  testing_grammar %{
+    grammar Foo
+      rule bar
+        "baz"
+      end
+    end
+  }
+
+  test "node cache storage and retrieval" do
+    parser = FooParser.new
+    parser.send(:prepare_to_parse, 'baz')
+    node_cache = parser.send(:node_cache)
+    
+    node_cache[:bar][0].should be_nil
+    
+    parser._nt_bar
+    
+    cached_node = node_cache[:bar][0]        
+    cached_node.should be_an_instance_of(Runtime::SyntaxNode)
+    cached_node.text_value.should == 'baz'
+    
+    parser.instance_eval { @index = 0 }
+    parser._nt_bar.should equal(cached_node)
+    parser.index.should == cached_node.interval.end
+  end
+end

data/test/compiler/sequence_test.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+ 
+class SequenceOfTerminalsTest < CompilerTestCase
+
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  testing_expression 'foo:"foo" bar:"bar" baz:"baz" <Foo> { def a_method; end }'
+  
+  test "successful result is an instance of the declared node class with element accessor methods and the method from the inline module" do
+    parse('foobarbaz') do |result|
+      result.should be_success
+      result.should be_an_instance_of(Foo)      
+      result.should respond_to(:a_method)
+      result.foo.text_value.should == 'foo'
+      result.bar.text_value.should == 'bar'
+      result.baz.text_value.should == 'baz'
+    end
+  end
+    
+  test "matching at a non-zero index" do
+    parse('---foobarbaz', :at_index => 3) do |result|
+      result.should be_success
+      result.should be_nonterminal
+      (result.elements.map {|elt| elt.text_value}).join.should == 'foobarbaz'
+    end
+  end
+  
+  test "non-matching input fails with a nested failure at the first terminal that did not match" do
+    parse('---foobazbaz', :at_index => 3) do |result|
+      result.should be_failure
+      result.index.should == 3
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 6
+      nested_failure.expected_string.should == 'bar'
+    end
+  end  
+end
+
+class SequenceOfNonterminalsTest < CompilerTestCase
+
+  testing_grammar %{
+    grammar TestGrammar
+      rule sequence
+        foo bar baz {
+          def baz
+            'override' + super.text_value
+          end
+        }
+      end
+      
+      rule foo 'foo' end
+      rule bar 'bar' end
+      rule baz 'baz' end
+    end
+  }
+  
+  test "accessors for nonterminals are automatically defined and can be overridden in the inline block" do
+    parse('foobarbaz') do |result|
+      result.foo.text_value.should == 'foo'
+      result.bar.text_value.should == 'bar'
+      result.baz.should == 'overridebaz'
+    end
+    
+    
+  end
+end

data/test/compiler/terminal_symbol_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TerminalSymbolTest < CompilerTestCase
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  testing_expression "'foo' <Foo> { def a_method; end }"
+
+  it "correctly parses matching input prefixes at various indices, returning an instance of the declared class that can respond to methods defined in the inline module" do
+    parse "foo", :at_index => 0 do |result|
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result.interval.should == (0...3)
+      result.text_value.should == 'foo'
+    end
+
+    parse "xfoo", :at_index => 1 do |result|
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result.interval.should == (1...4)
+      result.text_value.should == 'foo'
+    end
+    
+    parse "---foo", :at_index => 3 do |result|
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result.interval.should == (3...6)
+      result.text_value.should == 'foo'
+    end
+  end
+
+  it "fails to parse nonmatching input at the index even if a match occurs later" do
+    parse(" foo", :at_index =>  0).should be_failure
+  end
+end

data/test/compiler/test_grammar.treetop

@@ -0,0 +1,7 @@
+module Test
+  grammar Grammar
+    rule foo
+      'foo'
+    end
+  end
+end

data/test/compiler/zero_or_more_test.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ZeroOrMoreOfATerminalWithNodeClassDeclarationTest < CompilerTestCase
+  
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  testing_expression '"foo"* <Foo> { def a_method; end }'
+  
+  it "successfully parses epsilon, returning an instance declared node class with a nested failure" do
+    parse('') do |result|
+      result.should be_success
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 0
+      nested_failure.expected_string.should == 'foo'
+    end
+  end
+  
+  it "successfully parses two of that terminal in a row, returning an instance of the declared node class with a nested failure representing the third attempt " do
+    parse("foofoo") do |result|
+      result.should be_success
+      result.should be_an_instance_of(Foo)
+      result.nested_failures.size.should == 1
+      nested_failure = result.nested_failures.first
+      nested_failure.index.should == 6
+      nested_failure.expected_string.should == 'foo'
+    end
+  end
+end
+
+describe "Zero or more of a sequence", :extend => CompilerTestCase do
+  testing_expression '("foo" "bar")*'
+  
+  it "resets the index appropriately following partially matcing input" do
+    parse('foobarfoo') do |result|
+      result.should be_success
+      result.interval.should == (0...6)
+    end
+  end
+end
+
+describe "Zero or more of a choice", :extend => CompilerTestCase do
+  testing_expression '("a" / "b")*'
+
+  it "successfully parses matching input" do
+    parse('abba').should be_success
+  end
+end

data/test/composition/a.treetop

@@ -0,0 +1,11 @@
+module Test
+  grammar A
+    rule a
+      'a'
+    end
+    
+    rule inherit
+      'super'
+    end
+  end
+end

data/test/composition/b.treetop

@@ -0,0 +1,11 @@
+module Test
+  grammar B
+    rule b
+      'b'
+    end
+    
+    rule inherit
+      super 'keyword'
+    end
+  end
+end

data/test/composition/c.treetop

@@ -0,0 +1,10 @@
+module Test
+  grammar C
+    include A
+    include B
+    
+    rule c
+      a b 'c'
+    end
+  end
+end

data/test/composition/d.treetop

@@ -0,0 +1,10 @@
+module Test
+  grammar D
+    include A
+    include B
+    
+    rule inherit
+      super 'works'
+    end
+  end
+end

data/test/composition/grammar_composition_test.rb

@@ -0,0 +1,23 @@
+dir = File.dirname(__FILE__)
+require File.join(dir, '..', 'test_helper')
+
+class GrammarCompositionTest < Screw::Unit::TestCase
+  def setup
+    dir = File.dirname(__FILE__)
+    load_grammar File.join(dir, 'a')
+    load_grammar File.join(dir, 'b')
+    load_grammar File.join(dir, 'c')
+    load_grammar File.join(dir, 'd')
+    
+    @c = ::Test::CParser.new
+    @d = ::Test::DParser.new
+  end
+  
+  test "rules in C have access to rules defined in A and B" do
+    @c.parse('abc').should be_success
+  end
+  
+  test "rules in C can override rules in A and B with super semantics" do
+    @d.parse('superkeywordworks').should be_success
+  end
+end

data/test/parser/syntax_node_test.rb

@@ -0,0 +1,53 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../test_helper"
+
+describe "A new terminal syntax node" do
+  
+  def setup
+    @node = Runtime::SyntaxNode.new("input", 0...3)
+  end
+  
+  it "reports itself as terminal" do
+    @node.should be_terminal
+    @node.should_not be_nonterminal
+  end
+  
+  it "has a text value based on the input and the interval" do
+    @node.text_value.should == "inp"
+  end
+  
+  it "has no nested failures" do
+    @node.nested_failures.should be_empty
+  end
+  
+  it "has itself as its only element" do
+    @node.elements.should == [@node]
+  end
+end
+
+describe "A new nonterminal syntax node" do
+  def setup
+    @input = 'test input'
+    @nested_results = [Runtime::TerminalParseFailure.new(@input, 1, 'foo')]
+    @elements = Runtime::SyntaxNode.new('input', 0...3)
+    @node = Runtime::SyntaxNode.new('input', 0...3, @elements, @nested_results)
+  end
+
+  it "reports itself as nonterminal" do
+    @node.should be_nonterminal
+    @node.should_not be_terminal
+  end
+  
+  it "has a text value based on the input and the interval" do
+    @node.text_value.should == "inp"
+  end
+  
+  it "has the elements with which it was instantiated" do
+    @node.elements.should == @elements
+  end
+  
+  it "has nested failures frow within the nested results with which it was instantiated" do
+    @node.nested_failures.should == @nested_results
+  end
+  
+end