treetop 0.1.0 → 1.0.0

data/test/compilation_target/target.rb

@@ -0,0 +1,143 @@
+class Target < Treetop::Runtime::CompiledParser
+  class Bar < SyntaxNode
+    
+  end
+  
+  
+  attr_accessor :root
+  
+  def initialize
+    self.root = :foo
+  end
+  
+  def parse(input)
+    prepare_to_parse(input)
+    return self.send("_nt_#{root}".to_sym)
+  end
+  
+
+  module FooInlineModule
+    def foo
+      'foo'
+    end
+  end
+  
+  # parsing expression:
+  # 'a' ('b' 'c' / 'b' 'd')+ 'e' 
+
+  # lexical address assignment for results
+  # 'a' ('b' 'c' / 'b' 'd')+ 'e'
+  #       5   6     8   9     10
+  #         4         7
+  #              3
+  #  1           2
+  #              0
+  def _nt_foo
+    s0, i0 = [], index
+  
+    r1 = parse_terminal('a')
+    
+    s0 << r1
+    if s0.last.success?
+      # begin + closure
+      s2, nr2, i2 = [], [], index
+      loop do
+        # begin ('b' 'c' / 'b' 'd')
+        nr3, i3 = [], index
+        # begin 'b' 'c'
+        s4, i4 = [], index
+        r5 = parse_terminal('b')
+        s4 << r5
+        if s4.last.success?
+          r6 = parse_terminal('c')
+          s4 << r6
+        end
+          
+        if s4.last.success?
+          r4 = SyntaxNode.new(input, i4...index, s4)
+        else
+          self.index = i4
+          r4 = ParseFailure.new(input, i4, s4)
+        end
+        # end 'b' 'c'; result in r4
+        
+        nr3 << r4
+        
+        # test if we need to try expression 3's next alternative
+        if r4.success?
+          r3 = r4
+        else
+          # begin 'b' 'd'
+          s7, i7 = [], index
+          r8 = parse_terminal('b')
+          s7 << r8
+          if s7.last.success?
+            r9 = parse_terminal('d')
+            s7 << r9
+          end
+          
+          if s7.last.success?
+            r7 = SyntaxNode.new(input, i7...index, s7)
+          else
+            self.index = i7
+            r7 = ParseFailure.new(input, i7, s7)
+          end
+          # end 'b' 'c'; result in r7
+          
+          nr3 << r7
+          
+          if r7.success?
+            r3 = r7
+          else          
+            self.index = i3
+            r3 = ParseFailure.new(input, i3, nr3)
+          end
+        end                
+        # end ('b' 'c' / 'b' 'd'); result in r3 
+        nr2 << r3
+        if r3.success?
+          s2 << r3
+        else
+          break 
+        end
+      end
+      
+      # s2 has intermediate results of the + closure
+      if s2.empty?
+        self.index = i2
+        r2 = ParseFailure.new(input, i2, nr2)
+      else
+        r2 = SyntaxNode.new(input, i2...index, s2, nr2)
+      end      
+      # end + closure; results in r2
+      
+      s0 << r2 # put r2 on sequence
+    
+      if s0.last.success?
+        r10 = parse_terminal('e')
+        s0 << r10
+      end
+    
+      if s0.last.success?
+        r0 = Bar.new(input, i0...index, s0)
+      else
+        self.index = i0
+        r0 = ParseFailure.new(input, i0, s0)
+      end
+      # end of the sequence... r0 has a value
+      
+      r0.extend(FooInlineModule)
+      
+      return r0
+    end
+  end
+  
+  def _nt_optional
+    r1 = parse_terminal('foo')
+    if r1.success?
+      r0 = r1
+    else
+      r0 = SyntaxNode.new(input, index...index, r1.nested_failures)
+    end
+  end
+end

data/test/compilation_target/target.treetop

@@ -0,0 +1,15 @@
+module Target
+  class Bar < Treetop::Runtime::SyntaxNode
+    
+  end
+
+  grammar Foo
+    rule foo
+      'a' ('b' 'c' / 'b' 'd')+ 'e' <Bar> {
+        def foo
+          'foo'
+        end
+      }
+    end
+  end
+end

data/test/compilation_target/target_test.rb

@@ -0,0 +1,56 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../test_helper"
+
+require "#{dir}/target"
+
+describe "An instance of a hand-built Bar parser" do
+  
+  def setup
+    @parser = Target.new
+  end
+  
+  it "can parse matching input, associating it with the correct node class and that can respond to methods from the inlined module" do
+    result = @parser.parse('abce')
+    result.should be_success
+    result.should be_an_instance_of(Target::Bar)
+    result.foo.should == 'foo'
+  end
+  
+  it "can parse matching input that exercises foo's positive closure" do
+    @parser.parse('abcbcbce').should be_success
+  end
+  
+  it "can parse matching input that exercises foo's second alternative" do
+    @parser.parse('abde').should be_success
+  end
+  
+  it "fails to parse ae and returns the failure to match 'b' as its sole nested failure" do
+    result = @parser.parse('ae')
+    result.should be_failure
+    
+    result.nested_failures.size.should == 1
+    nested_failure = result.nested_failures.first
+    nested_failure.index.should == 1
+    nested_failure.expected_string.should == 'b'    
+  end
+  
+  it "fails to parse abe and returns the failure to match 'c' or 'd' as its nested failures" do
+    result = @parser.parse('abe')
+    result.should be_failure
+    result.nested_failures.size.should == 2
+  
+    nested_failure = result.nested_failures[0]
+    nested_failure.index.should == 2
+    nested_failure.expected_string.should == 'c'
+    
+    nested_failure = result.nested_failures[1]
+    nested_failure.index.should == 2
+    nested_failure.expected_string.should == 'd'
+  end
+  
+  it "parses the optional expression or epsilon" do
+    @parser.root = :optional    
+    @parser.parse('foo').should be_success
+    @parser.parse('').should be_success
+  end
+end

data/test/compiler/and_predicate_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+describe "An &-predicated terminal symbol", :extend => CompilerTestCase do
+  testing_expression '&"foo"'
+  
+  it "successfully parses input matching the terminal symbol, returning an epsilon syntax node" do
+    parse('foo') do |result|
+      result.should be_success
+      result.interval.should == (0...0)
+    end
+  end
+end
+
+describe "A sequence of a terminal and an and another &-predicated terminal", :extend => CompilerTestCase do
+  testing_expression '"foo" &"bar"'
+
+  it "matches input matching both terminals, but only consumes the first" do
+    parse('foobar') do |result|
+      result.should be_success
+      result.text_value.should == 'foo'
+    end
+  end
+  
+  it "fails to parse input matching only the first terminal, with the nested failure of the second" do
+    parse('foo') do |result|
+      result.should be_failure
+      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

data/test/compiler/anything_symbol_test.rb

@@ -0,0 +1,24 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../test_helper"
+
+class AnythingSymbolTest < CompilerTestCase  
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+  
+  testing_expression '. <Foo> { def a_method; end }'
+  
+  it "matches any single character in a big range, returning an instance of the declared node class that responds to methods defined in the inline module" do
+    (33..127).each do |digit|
+      parse(digit.chr) do |result|
+        result.should be_success
+        result.should be_an_instance_of(Foo)
+        result.should respond_to(:a_method)
+        result.interval.should == (0...1)
+      end
+    end
+  end
+  
+  it "fails to parse epsilon" do
+    parse('').should be_failure
+  end
+end

data/test/compiler/character_class_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class CharacterClassTest < CompilerTestCase
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  testing_expression "[A-Z] <Foo> { def a_method; end }"
+
+  it "matches single characters within that range, returning instances of the declared node class that respond to the method defined in the inline module" do
+    result = parse('A')
+    result.should be_an_instance_of(Foo)
+    result.should respond_to(:a_method)
+    result = parse('N')
+    result.should be_an_instance_of(Foo)
+    result.should respond_to(:a_method)
+    result = parse('Z')
+    result.should be_an_instance_of(Foo)
+    result.should respond_to(:a_method)
+  end
+  
+  it "does not match single characters outside of that range" do
+    parse('8').should be_failure
+    parse('a').should be_failure
+  end
+  
+  it "matches a single character within that range at index 1" do
+    parse(' A', :at_index => 1).should be_success
+  end
+  
+  it "fails to match a single character out of that range at index 1" do
+    parse(' 1', :at_index => 1).should be_failure
+  end
+end
+
+describe "A character class containing quotes", :extend => CompilerTestCase do
+  testing_expression "[\"']"
+  
+  it "matches a quote" do
+    parse("'").should be_success
+  end
+  
+  it "matches a double-quote" do
+    parse('"').should be_success
+  end
+end

data/test/compiler/choice_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+describe "A choice between terminal symbols", :extend => CompilerTestCase do
+  testing_expression '"foo" { def foo_method; end } / "bar" { def bar_method; end } / "baz" { def baz_method; end }'
+
+  it "successfully parses input matching any of the alternatives, returning a node that responds to methods defined in its respective inline module" do
+    result = parse('foo')
+    result.should be_success
+    result.should respond_to(:foo_method)
+    
+    result = parse('bar')
+    result.should be_success
+    result.should respond_to(:bar_method)
+    
+    result = parse('baz')
+    result.should be_success
+    result.should respond_to(:baz_method)
+  end
+  
+  it "attaches the nested failure of the first terminal to a successful parsing of input matching the second" do
+    result = parse('bar')
+    result.nested_failures.size.should == 1
+    nested_failure = result.nested_failures[0]
+    nested_failure.expected_string.should == 'foo'
+    nested_failure.index.should == 0
+  end
+  
+  it "attaches the nested failure of the first and second terminal to a successful parsing of input matching the third" do
+    result = parse('baz')
+    result.nested_failures.size.should == 2
+
+    first_nested_failure = result.nested_failures[0]
+    first_nested_failure.expected_string == 'foo'
+    first_nested_failure.index.should == 0
+    
+    first_nested_failure = result.nested_failures[1]
+    first_nested_failure.expected_string == 'bar'
+    first_nested_failure.index.should == 0
+  end
+end
+
+describe "A choice between sequences", :extend => CompilerTestCase do
+  testing_expression "'foo' 'bar' 'baz'\n/\n'bing' 'bang' 'boom'"
+
+  it "successfully parses input matching any of the alternatives" do
+    parse('foobarbaz').should be_success
+    parse('bingbangboom').should be_success
+  end
+end

data/test/compiler/circular_compilation_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require 'benchmark'
+
+class CircularCompilationTest < CompilerTestCase
+  test "the generated metagrammar parser can parse the treetop file whence it came" do
+    File.open(METAGRAMMAR_PATH, 'r') do |file|
+      input = file.read
+      result = Treetop::Compiler::MetagrammarParser.new.parse(input)
+      result.should be_success
+            
+      Treetop::Compiler.send(:remove_const, :Metagrammar)
+      parser_code = result.compile
+      
+      Object.class_eval(parser_code)
+      
+      r = Treetop::Compiler::MetagrammarParser.new.parse(input)
+      r.should be_success
+    end
+  end
+end

data/test/compiler/failure_propagation_functional_test.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+describe "An expression for braces surrounding zero or more letters followed by semicolons", :extend => CompilerTestCase do
+  testing_expression "'{' ([a-z] ';')* '}'"
+  
+  it "parses matching input successfully" do
+    parse('{a;b;c;}').should be_success
+  end
+  
+  it "fails to parse input with an expression that is missing a semicolon, reporting the correct nested failure" do
+    parse('{a;b;c}') do |result|
+      result.should be_failure
+      
+      result.nested_failures.size.should == 1      
+      nested_failure = result.nested_failures[0]
+      nested_failure.index.should == 6
+      nested_failure.expected_string.should == ';'
+    end
+  end
+end

data/test/compiler/grammar_compiler_test.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class GrammarCompilerTest < Screw::Unit::TestCase
+  
+  def setup
+    @compiler = Compiler::GrammarCompiler.new
+    @source_path = File.join(File.dirname(__FILE__), 'test_grammar.treetop')
+    @target_path = File.join(File.dirname(__FILE__), 'test_grammar.rb')
+    @alternate_target_path = File.join(File.dirname(__FILE__), 'test_grammar_alt.rb')
+    delete_target_files
+  end
+  
+  def teardown
+    delete_target_files
+    Object.class_eval do
+      remove_const(:Test) if const_defined?(:Test)
+    end
+  end
+  
+  test "compilation of a single file to a default file name" do
+    assert !File.exists?(@target_path)
+    @compiler.compile(@source_path)
+    assert File.exists?(@target_path)
+    require @target_path
+    Test::GrammarParser.new.parse('foo').should be_success
+  end
+  
+  test "compilation of a single file to an explicit file name" do
+    assert !File.exists?(@alternate_target_path)
+    @compiler.compile(@source_path, @alternate_target_path)
+    assert File.exists?(@alternate_target_path)
+    require @alternate_target_path
+    Test::GrammarParser.new.parse('foo').should be_success
+  end
+  
+  test "compilation of a single file without writing it to an output file" do
+    @compiler.ruby_source(@source_path).should_not be_nil
+  end
+
+  test "load_grammar compiles and evaluates source grammar with extension" do    
+    load_grammar @source_path
+    Test::GrammarParser.new.parse('foo').should be_success
+  end
+
+  test "load_grammar compiles and evaluates source grammar with no extension" do
+    path_without_extension = @source_path.gsub(/\.treetop\Z/, '')
+    load_grammar path_without_extension
+    Test::GrammarParser.new.parse('foo').should be_success
+  end
+  
+  
+  def delete_target_files
+    File.delete(@target_path) if File.exists?(@target_path)
+    File.delete(@alternate_target_path) if File.exists?(@alternate_target_path)
+  end
+  
+end
+