treetop 1.5.3 → 1.6.12

data/spec/compiler/sequence_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-module SequenceSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "a sequence of labeled terminal symbols followed by a node class declaration and a block" do
-    testing_expression 'foo:"foo" bar:"bar" baz:"baz" <SequenceSpec::Foo> { def a_method; end }'
-
-    it "upon successfully matching input, instantiates 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_not be_nil
-        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
-
-    it "successfully matches at a non-zero index" do
-      parse('---foobarbaz', :index => 3) do |result|
-        result.should_not be_nil
-        result.should be_nonterminal
-        (result.elements.map {|elt| elt.text_value}).join.should == 'foobarbaz'
-      end
-    end
-
-    it "fails to match non-matching input, recording the parse failure of first non-matching terminal" do
-      parse('---foobazbaz', :index => 3) do |result|
-        result.should be_nil
-        parser.index.should == 3
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-        failure = terminal_failures.first
-        failure.index.should == 6
-        failure.expected_string.should == 'bar'
-      end
-    end
-  end
-
-  module ModFoo
-  def mod_method; end
-  end
-
-  describe "a sequence of labeled terminal symbols followed by a node module declaration and a block" do
-    testing_expression 'foo:"foo" bar:"bar" baz:"baz" <SequenceSpec::ModFoo> { def a_method; end }'
-
-    it "upon successfully matching input, instantiates a syntax node and extends it with the declared module, element accessor methods, and the method from the inline module" do
-      parse('foobarbaz') do |result|
-        result.should_not be_nil
-        result.should respond_to(:mod_method)
-        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-        result.should be_a_kind_of(ModFoo)
-        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
-  end
-
-  describe "a labeled single element sequence followed by a node module declaration and a block" do
-    testing_expression 'foo:"foo"+ <SequenceSpec::ModFoo> { def a_method; end }'
-    it "upon successfully matching input, instantiates a syntax node and extends it with the declared module, element accessor methods, and the method from the inline module" do
-      parse('foofoofoo') do |result|
-        result.should_not be_nil
-        result.should respond_to(:mod_method)
-        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-        result.should be_a_kind_of(ModFoo)
-        result.should respond_to(:a_method)
-        result.foo.text_value.should == 'foofoofoo'
-      end
-    end
-  end
-
-  describe "a sequence of non-terminals" do
-    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
-    }
-
-    it "defines accessors for non-terminals automatically that 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
-
-  describe "Compiling a sequence containing various white-space errors" do
-    it "should succeed on a valid sequence" do
-      compiling_expression('foo:"foo" "bar" <SequenceSpec::Foo> { def a_method; end }').should_not raise_error
-    end
-
-    it "rejects space after a label" do
-      compiling_expression('foo :"foo" "bar"').should raise_error(RuntimeError)
-    end
-
-    it "rejects space after label's colon" do
-      compiling_expression('foo: "foo" "bar"').should raise_error(RuntimeError)
-    end
-
-    it "rejects missing space after a primary" do
-      compiling_expression('foo:"foo""bar"').should raise_error(RuntimeError)
-    end
-
-    it "rejects missing space before node class declaration" do
-      compiling_expression('foo:"foo" "bar"<SequenceSpec::Foo>').should raise_error(RuntimeError)
-    end
-    
-    it "rejects missing space before inline module" do
-      compiling_expression('foo:"foo" "bar" <SequenceSpec::Foo>{def a_method; end}').should raise_error(RuntimeError)
-    end
-  end
-
-end

data/spec/compiler/terminal_spec.rb

@@ -1,170 +0,0 @@
-require 'spec_helper'
-
-module TerminalSymbolSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "a terminal symbol" do
-    testing_expression "'Foo'"
-
-    it "matches the input string" do
-      parse "Foo", :index => 0 do |result|
-        result.should_not be_nil
-        result.interval.should == (0...3)
-        result.text_value.should == 'Foo'
-      end
-    end
-
-    it "fails to match the input string other than at the start" do
-      parse " Foo", :index => 0 do |result|
-        result.should be_nil
-      end
-    end
-
-    it "fails to match the input string in the wrong case" do
-      parse "foo", :index => 0 do |result|
-        result.should be_nil
-      end
-    end
-  end
-
-  describe "a terminal symbol with case-insensitive matching" do
-    testing_expression "'Foo'i"
-
-    it "matches the input string in the same case" do
-      parse "Foo", :index => 0 do |result|
-        result.should_not be_nil
-        result.interval.should == (0...3)
-        result.text_value.should == 'Foo'
-      end
-    end
-
-    it "matches the input string in varied case" do
-      parse "foO", :index => 0 do |result|
-        result.should_not be_nil
-        result.interval.should == (0...3)
-        result.text_value.should == 'foO'
-      end
-    end
-  end
-
-  describe "a terminal symbol followed by a node class declaration and a block" do
-    testing_expression "'foo' <TerminalSymbolSpec::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", :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", :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", :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", :index =>  0).should be_nil
-    end
-  end
-
-  module ModFoo
-  end
-
-  describe "a terminal symbol followed by a node class declaration and a block" do
-    testing_expression "'foo' <TerminalSymbolSpec::ModFoo> { def a_method; end }"
-
-    it "correctly parses matching input prefixes at various indices, returning an instance of SyntaxNode extended with the declared module that can respond to methods defined in the inline module" do
-      parse "foo", :index => 0 do |result|
-        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-        result.should be_a_kind_of(ModFoo)
-        result.should respond_to(:a_method)
-        result.interval.should == (0...3)
-        result.text_value.should == 'foo'
-      end
-
-      parse "xfoo", :index => 1 do |result|
-        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-        result.should be_a_kind_of(ModFoo)
-        result.should respond_to(:a_method)
-        result.interval.should == (1...4)
-        result.text_value.should == 'foo'
-      end
-    
-      parse "---foo", :index => 3 do |result|
-        result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-        result.should be_a_kind_of(ModFoo)
-        result.should respond_to(:a_method)
-        result.interval.should == (3...6)
-        result.text_value.should == 'foo'
-      end
-    end
-  end
-
-  describe "a terminal regexp" do
-    testing_expression "'Fo+'r"
-
-    it "matches the input string" do
-      parse "Fooo", :index => 0 do |result|
-        result.should_not be_nil
-        result.interval.should == (0...4)
-        result.text_value.should == 'Fooo'
-      end
-    end
-
-    it "fails to match the input string other than at the start" do
-      parse " Foo", :index => 0 do |result|
-        result.should be_nil
-      end
-    end
-
-    it "fails to match the input string in the wrong case" do
-      parse "foo", :index => 0 do |result|
-        result.should be_nil
-      end
-    end
-  end
-
-  describe "a case-insensitive terminal regexp" do
-    testing_expression "'Fo+'ri"
-
-    it "matches the input string in the same case" do
-      parse "Fooo", :index => 0 do |result|
-        result.should_not be_nil
-        result.interval.should == (0...4)
-        result.text_value.should == 'Fooo'
-      end
-    end
-
-    it "matches the input string in the same case" do
-      parse "foOo", :index => 0 do |result|
-        result.should_not be_nil
-        result.interval.should == (0...4)
-        result.text_value.should == 'foOo'
-      end
-    end
-  end
-
-#  Transient symbols were part of some idea of Nathan's that I no longer recall
-#  describe "a transient terminal symbol" do
-#    testing_expression "~'foo'"
-#
-#    it "returns true upon parsing matching input prefixes at various indices" do
-#      pending "transient terminal expressions"
-#      parse("foo", :index => 0).should be_true
-#      parse("-foo", :index => 1).should be_true
-#      parse("---foo", :index => 3).should be_true
-#    end
-#  end
-end

data/spec/compiler/terminal_symbol_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-module TerminalSymbolSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "a terminal symbol followed by a node class declaration and a block" do
-    testing_expression "'foo' <TerminalSymbolSpec::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", :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", :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", :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", :index =>  0).should be_nil
-    end
-  end
-end

data/spec/compiler/test_grammar.treetop

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

data/spec/compiler/test_grammar.tt

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

data/spec/compiler/test_grammar_do.treetop

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

data/spec/compiler/test_grammar_magic_coding.treetop

@@ -1,8 +0,0 @@
-# coding: UTF-8
-module Test
-  grammar Grammar do
-    rule foo do
-      'foo'
-    end
-  end
-end

data/spec/compiler/test_grammar_magic_encoding.treetop

@@ -1,8 +0,0 @@
-# encoding: UTF-8
-module Test
-  grammar Grammar do
-    rule foo do
-      'foo'
-    end
-  end
-end

data/spec/compiler/tt_compiler_spec.rb

@@ -1,224 +0,0 @@
-require 'digest/sha1'
-require 'tmpdir'
-
-# ensure the Kernel.system and Kernel.open's always use the correct tt and
-# Treetop library versions, not a previously installed gem
-ENV['PATH'] = File.expand_path(File.dirname(__FILE__) + '../../../bin' +
-                              File::PATH_SEPARATOR + ENV['PATH'])
-$LOAD_PATH.unshift(File.expand_path('../../../../lib', __FILE__))
-
-describe "The 'tt' comand line compiler" do
-  before(:each) do
-    @tmpdir = Dir.tmpdir
-  end
-
-  context 'when processing a single grammar file' do
-    before(:each) do
-      # create a fresh but dumb grammar file for each example
-      @test_base = "dumb-#{rand(1000)}"
-      @test_path = "#{@tmpdir}/#{@test_base}"
-      @test_grammar = "#{@test_path}.tt"
-      @test_ruby = "#{@test_path}.rb"
-      File.open(@test_grammar, 'w+') do |f|
-        f.print("# Encoding: UTF-8\n")
-        f.print("grammar Dumb\n")
-        f.print("end\n")
-      end unless File.exists?(@test_grammar)
-    end
-
-    after(:each) do
-      # cleanup test grammar and parser output files
-      File.delete(@test_grammar) if File.exists?(@test_grammar)
-      File.delete(@test_ruby) if File.exists?(@test_ruby)
-    end
-
-    it 'can compile a grammar file' do
-      # puts %q{emulate 'tt dumb.tt'}
-      system("ruby -S tt #{@test_grammar}").should be_true
-
-      File.exists?(@test_ruby).should be_true
-      File.zero?(@test_ruby).should_not be_true
-    end
-
-    it 'can compile a relative pathed grammar file' do
-      dir = File.basename(File.expand_path(File.dirname(@test_grammar)))
-
-      # puts %q{emulate 'tt "../<current_dir>/dumb.tt"'}
-      system("cd #{@tmpdir}/..; ruby -S tt \"./#{dir}/#{@test_base}.tt\"").should be_true
-
-      File.exists?(@test_ruby).should be_true
-      File.zero?(@test_ruby).should_not be_true
-    end
-
-    it 'can compile an absolute pathed grammar file' do
-      # puts %q{emulate 'tt "/path/to/dumb.tt"'}
-      system("ruby -S tt \"#{File.expand_path(@test_grammar)}\"").should be_true
-
-      File.exists?(@test_ruby).should be_true
-      File.zero?(@test_ruby).should_not be_true
-    end
-
-    it 'can compile without explicit file extensions' do
-      # puts %q{emulate 'tt dumb'}
-      system("ruby -S tt #{@test_path}").should be_true
-
-      File.exists?(@test_ruby).should be_true
-      File.zero?(@test_ruby).should_not be_true
-    end
-
-    it 'skips nonexistent grammar file without failing or creating bogus output' do
-      # puts %q{emulate 'tt dumb.bad'}
-      Kernel.open("|ruby -S tt #{@test_base}.bad") do |io|
-        (io.read =~ /ERROR.*?not exist.*?continuing/).should_not be_nil
-      end
-
-      File.exists?("#{@test_base}.rb").should be_false
-    end
-
-    it 'can compile to a specified parser source file' do
-      # puts %q{emulate 'tt -o my_dumb_test_parser.rb dumb'}
-      pf = "#{@tmpdir}/my_dumb_test_parser.rb"
-      begin
-        system("ruby -S tt -o #{pf} #{@test_path}").should be_true
-
-        File.exists?(pf).should be_true
-        File.zero?(pf).should_not be_true
-      ensure
-        File.delete(pf) if File.exists?(pf)
-      end
-    end
-
-    it 'by default, does not overwrite an existing file without an autogenerated header' do
-      # puts %q{emulate 'tt -o must_save_parser.rb dumb'}
-      pf = "#{@tmpdir}/must_save_parser.rb"
-      begin
-        system("ruby -S tt -o #{pf} #{@test_path}").should be_true
-
-        File.exists?(pf).should be_true
-        File.zero?(pf).should_not be_true
-
-        # Check that the magic comment is preserved:
-        written = File.open(pf, "r") { |f| s = f.read }
-        written.should =~ /\A# Encoding: UTF-8/
-
-        # Modify the file's auto-generated comment and make sure it doesn't get overwritten:
-        written.sub!(/generated/, 'broken');
-        File.open(pf, "w") { |f| f.write(written) }
-        # File.open(pf, "r+") { |f| s = f.read; s.sub!(/generated/, 'broken'); f.rewind; f.write(s) }
-        orig_file_hash = Digest::SHA1.hexdigest(File.read(pf))
-
-        Kernel.open("|ruby -S tt -o #{pf} #{@test_path}") do |io|
-          (io.read =~ /ERROR.*?already exists.*?skipping/).should_not be_nil
-        end
-
-        Digest::SHA1.hexdigest(File.read(pf)).should == orig_file_hash
-      ensure
-        File.delete(pf) if File.exists?(pf)
-      end
-    end
-
-    it 'by default, overwrites a changed file with an intact autogenerated header' do
-      # puts %q{emulate 'tt -o must_save_parser.rb dumb'}
-      pf = "#{@tmpdir}/must_save_parser.rb"
-      begin
-        system("ruby -S tt -o #{pf} #{@test_path}").should be_true
-
-        File.exists?(pf).should be_true
-        File.zero?(pf).should_not be_true
-        orig_file_hash = Digest::SHA1.hexdigest(File.read(pf))
-
-        # Modify the file and make sure it gets reverted:
-        File.open(pf, "r+") { |f| f.gets; f.write("#") }
-
-        system("ruby -S tt -o #{pf} #{@test_path}").should be_true
-        Digest::SHA1.hexdigest(File.read(pf)).should == orig_file_hash
-      ensure
-        File.delete(pf) if File.exists?(pf)
-      end
-    end
-
-    it 'can be forced to overwrite existing file #{@test_path}' do
-      pf = "#{@test_path}.rb"
-      system("echo some junk >#{pf}").should be_true
-
-      File.exists?(pf).should be_true
-      File.zero?(pf).should_not be_true
-      orig_file_hash = Digest::SHA1.hexdigest(File.read(pf))
-
-      system("ruby -S tt -f #{@test_path}").should be_true
-      Digest::SHA1.hexdigest(File.read(pf)).should_not == orig_file_hash
-    end
-
-  end
-
-  context 'when processing multiple grammar files' do
-
-    before(:each) do
-      # provide fresh but dumb grammar files for each test
-      @test_bases = []
-      @test_grammars = []
-
-      %w[dumb1 dumb2].each do |e|
-        base = "#{@tmpdir}/#{e}-#{rand(1000)}"
-        grammar_file = "#{base}.tt"
-        @test_bases << base
-        @test_grammars << grammar_file
-
-        File.open(grammar_file, 'w+') do |f|
-          f.print("grammar #{e.capitalize}\n")
-          f.print("end\n")
-        end unless File.exists?(grammar_file)
-      end
-    end
-
-    after(:each) do
-      # cleanup test grammar and output parser files
-      @test_grammars.each { |f| File.delete(f) if File.exists?(f) }
-      @test_bases.each { |f| File.delete("#{f}.rb") if File.exists?("#{f}.rb") }
-    end
- 
-    it 'can compile them in one invocation' do
-      # puts %q{emulate 'tt dumb1.tt dumb2.tt'}
-      system("ruby -S tt #{@test_grammars.join(' ')}").should be_true
-
-      @test_bases.each do |f|
-        pf = "#{f}.rb"
-        File.exists?(pf).should be_true
-        File.zero?(pf).should_not be_true
-      end
-    end
-
-    it 'can compile them without explicit file extenstions' do
-      # puts %q{emulate 'tt dumb1 dumb2'}
-      system("ruby -S tt #{@test_bases.join(' ')}").should be_true
-
-      @test_bases.each do |f|
-        pf = "#{f}.rb"
-        File.exists?(pf).should be_true
-        File.zero?(pf).should_not be_true
-      end
-    end
-
-    it 'can skip nonexistent and invalid extension named grammar files' do
-      # puts %q{emulate 'tt not_here bad_ext.ttg dumb1 dumb2'}
-      system("ruby -S tt not_here bad_ext.ttg #{@test_bases.join(' ')} >/dev/null 2>&1").should be_true
-
-      File.exists?('not_here.rb').should_not be_true
-      File.exists?('bad_ext.rb').should_not be_true
-
-      @test_bases.each do |f|
-        pf = "#{f}.rb"
-        File.exists?(pf).should be_true
-        File.zero?(pf).should_not be_true
-      end
-    end
-
-    it 'can not specify an output file' do
-      # puts %q{emulate 'tt -o my_bogus_test_parser.rb dumb1 dumb2'}
-      pf = 'my_bogus_test_parser.rb'
-      system("ruby -S tt -o #{pf} #{@test_bases.join(' ')} >/dev/null 2>&1").should be_false
-      File.exists?(pf).should be_false
-    end
-  end
-
-end

data/spec/compiler/zero_or_more_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-module ZeroOrMoreSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "zero or more of a terminal symbol followed by a node class declaration and a block" do
-    testing_expression '"foo"* <ZeroOrMoreSpec::Foo> { def a_method; end }'
-
-    it "successfully parses epsilon, returning an instance declared node class and recording a terminal failure" do
-      parse('') do |result|
-        result.should_not be_nil
-        result.should be_an_instance_of(Foo)
-        result.should respond_to(:a_method)
-
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-        failure = terminal_failures.first
-        failure.index.should == 0
-        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 and recording a failure representing the third attempt " do
-      parse("foofoo") do |result|
-        result.should_not be_nil
-        result.should be_an_instance_of(Foo)
-
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-        failure = terminal_failures.first
-        failure.index.should == 6
-        failure.expected_string.should == 'foo'
-      end
-    end
-  end
-
-  describe "Zero or more of a sequence" do
-    testing_expression '("foo" "bar")*'
-
-    it "resets the index appropriately following partially matcing input" do
-      parse('foobarfoo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.interval.should == (0...6)
-      end
-    end
-  end
-
-  describe "Zero or more of a choice" do
-    testing_expression '("a" / "bb")*'
-
-    it "successfully parses matching input" do
-      parse('abba').should_not be_nil
-    end
-  end
-end

data/spec/composition/a.treetop

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

data/spec/composition/b.treetop

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