treetop 1.1.2 → 1.1.4

data/test/compilation_target/target.rb

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

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

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

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

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

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

@@ -1,74 +0,0 @@
-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
-
-describe "A choice between terminals followed by a block", :extend => CompilerTestCase do  
-  testing_expression "('a'/ 'b' / 'c') { def a_method; end }"
-
-  it "extends a match of any of its subexpressions with a module created from the block" do
-    ['a', 'b', 'c'].each do |letter|
-      parse(letter).should respond_to(:a_method)
-    end
-  end
-end
-
-class ChoiceWithDeclaredModuleTest < CompilerTestCase
-  module TestModule
-    def a_method
-    end
-  end
-  
-  testing_expression "('a'/ 'b' / 'c') <TestModule>"
-
-  it "extends a match of any of its subexpressions with a module created from the block" do
-    ['a', 'b', 'c'].each do |letter|
-      parse(letter).should respond_to(:a_method)
-    end
-  end
-end

data/test/compiler/circular_compilation_test.rb

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

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

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