treetop 1.1.2 → 1.1.4

data/test/compiler/grammar_test.rb

@@ -1,37 +0,0 @@
-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 "fails if it does not parse all input" do
-    parse('barbarbazbaz').should be_failure
-  end
-  
-  it "mixes in included modules" do
-    Foo.ancestors.should include(Bar)
-  end
-end

data/test/compiler/nonterminal_symbol_test.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-describe "A nonterminal symbol followed by a block", :extend => CompilerTestCase do
-  testing_expression 'foo { def a_method; end }'
-  
-  parser_class_under_test.class_eval do
-    def _nt_foo
-      '_nt_foo called'
-    end
-  end
-  
-  it "compiles to a method call, extending its results with the anonymous module for the block" do
-    result = parse('')
-    result.should == '_nt_foo called'
-    result.should respond_to(:a_method)
-  end
-end
-
-class NonterminalWithModuleDeclationTest < CompilerTestCase
-  module TestModule
-    def a_method
-    end
-  end
-  
-  testing_expression 'foo <TestModule>'
-  
-  parser_class_under_test.class_eval do
-    def _nt_foo
-      '_nt_foo called'
-    end
-  end
-  
-  it "compiles to a method call, extending its results with the anonymous module for the block" do
-    result = parse('')
-    result.should == '_nt_foo called'
-    result.should respond_to(:a_method)
-  end
-end

data/test/compiler/not_predicate_test.rb

@@ -1,35 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/parenthesized_expression_test.rb

@@ -1,17 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-describe "An unadorned expression inside of parentheses", :extend => CompilerTestCase do
-  testing_expression '("foo")'
-  
-  it "should behave as normal" do
-    parse('foo').should be_success
-  end
-end
-
-describe "A prefixed-expression inside of parentheses", :extend => CompilerTestCase do
-  testing_expression '(!"foo")'
-  
-  it "should behave as normal" do
-    parse('foo').should_not be_success
-  end
-end

data/test/compiler/parsing_rule_test.rb

@@ -1,30 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

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

data/test/compiler/zero_or_more_test.rb

@@ -1,51 +0,0 @@
-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

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

data/test/composition/b.treetop

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

data/test/composition/c.treetop

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

data/test/composition/d.treetop

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