treetop 1.5.3 → 1.6.12

data/spec/compiler/character_class_spec.rb

@@ -1,301 +0,0 @@
-require 'spec_helper'
-
-module CharacterClassSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "a character class followed by a node class declaration and a block" do
-
-    testing_expression "[A-Z] <CharacterClassSpec::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_nil
-      parse('a').should be_nil
-    end
-
-    it "matches a single character within that range at index 1" do
-      parse(' A', :index => 1).should_not be_nil
-    end
-
-    it "fails to match a single character out of that range at index 1" do
-      parse(' 1', :index => 1).should be_nil
-    end
-  end
-
-  module ModFoo
-  end
-
-  describe "a character class followed by a node module declaration and a block" do
-
-    testing_expression "[A-Z] <CharacterClassSpec::ModFoo> { def a_method; end }"
-
-    it "matches single characters within that range, returning instances of SyntaxNode extended by the specified module" do
-      result = parse('A')
-      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-      result.should be_a_kind_of(ModFoo)
-      result.should respond_to(:a_method)
-      result = parse('N')
-      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-      result.should be_a_kind_of(ModFoo)
-      result.should respond_to(:a_method)
-      result = parse('Z')
-      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-      result.should be_a_kind_of(ModFoo)
-      result.should respond_to(:a_method)
-    end
-
-    it "does not match single characters outside of that range" do
-      parse('8').should be_nil
-      parse('a').should be_nil
-    end
-
-    it "matches a single character within that range at index 1" do
-      parse(' A', :index => 1).should_not be_nil
-    end
-
-    it "fails to match a single character out of that range at index 1" do
-      parse(' 1', :index => 1).should be_nil
-    end
-  end
-
-  describe "a character class with a POSIX bracket expression" do
-    testing_expression "[[:digit:]]"
-    it "matches a single character within the class" do
-      parse('1').should_not be_nil
-    end
-    it "does not match a single character outside the class" do
-      parse('a').should be_nil
-      parse('-').should be_nil
-    end
-    testing_expression "[[:digit:][:space:]]+"
-    it "matches a string with a mix of two character classes" do
-      parse('1 4 9').should_not be_nil
-    end
-  end
-
-  describe "a character class with a negated POSIX bracket expression" do
-    testing_expression "[^[:space:]]"
-    it "matches a character outside the negated class" do
-      parse('a').should_not be_nil
-    end
-    it "doesn't match a character within the negated class" do
-      parse(' ').should be_nil
-    end
-  end
-
-  describe "a character class followed by a node class declaration and a block" do
-
-    testing_expression "[A-Z] <CharacterClassSpec::Foo>"
-    
-    it "actively generates nodes for the character when it is the primary node" do
-      result = parse('A')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-    
-  end
-
-  describe "A character class containing quotes" do
-    testing_expression "[\"']"
-
-    it "matches a quote" do
-      parse("'").should_not be_nil
-    end
-
-    it "matches a double-quote" do
-      parse('"').should_not be_nil
-    end
-  end
-
-  describe "A character class containing a special character" do
-    testing_expression "[\t]"
-    it "matches that character only" do
-      parse("\t").should_not be_nil
-      parse('t').should be_nil
-    end
-  end
-
-  describe "A character class containing an escaped backslash" do
-    slash = "\\"  # Make it explicit that there are *two* backslashes here
-    testing_expression "[#{slash}#{slash}]"
-    it "matches a backslash only" do
-      parse("\\").should_not be_nil
-      parse('t').should be_nil
-    end
-  end
-
-  describe "A character class containing a hex escape" do
-    slash = "\\"
-    testing_expression "[#{slash}x41]"
-    it "matches that character only" do
-      parse('A').should_not be_nil
-      parse('\\').should be_nil
-      parse('x').should be_nil
-      parse('4').should be_nil
-      parse('1').should be_nil
-    end
-  end
-
-  describe "A character class containing an octal escape" do
-    slash = "\\"
-    testing_expression "[#{slash}101]"
-    it "matches that character only" do
-      parse('A').should_not be_nil
-      parse('\\').should be_nil
-      parse('1').should be_nil
-      parse('0').should be_nil
-    end
-  end
-
-  describe "A character class containing a \\c control-char escape" do
-    slash = "\\"
-    testing_expression "[#{slash}cC]"
-    it "matches that character only" do
-      parse("\003").should_not be_nil
-      parse('\\').should be_nil
-      parse('c').should be_nil
-      parse('C').should be_nil
-    end
-  end
-
-  describe "A character class containing a \\C- control-char escape" do
-    slash = "\\"
-    testing_expression "[#{slash}C-C]"
-    it "matches that character only" do
-      parse("\003").should_not be_nil
-      parse('\\').should be_nil
-      parse('C').should be_nil
-      parse('-').should be_nil
-    end
-  end
-
-  if RUBY_VERSION =~ /\A1\.8\./
-    describe "A character class containing a \\M- meta-char escape" do
-      slash = "\\"
-      testing_expression "[#{slash}M- ]"
-      it "matches that character only" do
-        parse("\240").should_not be_nil
-        parse('\\').should be_nil
-        parse('M').should be_nil
-        parse('-').should be_nil
-        parse(' ').should be_nil
-      end
-    end
-  end
-
-  describe "A character class containing an escaped non-special character" do
-    slash = "\\"
-    testing_expression "[#{slash}y]"
-    it "matches that character only" do
-      parse("y").should_not be_nil
-      parse('\\').should be_nil
-    end
-  end
-
-  describe "A character class containing an \#{...} insertion" do
-    testing_expression "[\#{raise 'error'}]"
-    it "doesn't evaluate the insertion" do
-      x = true
-      lambda{
-	x = parse("y")
-      }.should_not raise_error
-      x.should be_nil
-      parse('#').should_not be_nil
-      parse("'").should_not be_nil
-      parse("0").should be_nil
-    end
-  end
-  
-  describe "a character class" do
-    testing_expression "[A-Z]"
-    it "actively generates a node for the character because it is the primary node" do
-      result = parse('A')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-  end
-  
-  describe "a character class mixed with other expressions" do
-    testing_expression '[A-Z] "a" "bc"'
-    it "lazily instantiates a node for the character" do
-      result = parse('Aabc')
-      result.instance_variable_get("@elements").should include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 3
-    end
-  end
-  
-  describe "a character class with a node class declaration mixed with other expressions" do
-    testing_expression '([A-Z] <CharacterClassSpec::Foo>) "ab"'
-    it "actively generates a node for the character because it has a node class declared" do
-      result = parse('Aab')
-      result.instance_variable_get("@elements").should_not include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with a node module declaration mixed with other expressions" do
-    testing_expression '([A-Z] <CharacterClassSpec::ModFoo>) "ab"'
-    it "actively generates a node for the character because it has a node module declared" do
-      result = parse('Aab')
-      result.instance_variable_get("@elements").should_not include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with an inline block mixed with other expressions" do
-    testing_expression '([A-Z] { def a_method; end }) "ab"'
-    it "actively generates a node for the character because it has an inline block" do
-      result = parse('Aab')
-      result.instance_variable_get("@elements").should_not include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with a label mixed with other expressions" do
-    testing_expression 'upper:([A-Z]) "b" "cd"'
-    it "returns the correct element for the labeled expression" do
-      result = parse('Abcd')
-      result.upper.text_value.should == "A"
-      result.elements.size.should == 3
-    end
-  end
-  
-  describe "a character class repetition mixed with other expressions" do
-    testing_expression '[A-Z]+ "a" "bc"'
-    it "lazily instantiates a node for the character" do
-      result = parse('ABCabc')
-      result.elements[0].instance_variable_get("@elements").should include(true)
-      result.elements[0].elements.should_not include(true)
-      result.elements[0].elements.size.should == 3
-      result.elements.size.should == 3
-      result.elements.inspect.should == %Q{[SyntaxNode offset=0, "ABC":\n  SyntaxNode offset=0, "A"\n  SyntaxNode offset=1, "B"\n  SyntaxNode offset=2, "C", SyntaxNode offset=3, "a", SyntaxNode offset=4, "bc"]}
-    end
-  end
-  
-  describe "a character class that gets cached because of a choice" do
-    testing_expression "[A-Z] 'a' 'bc' / [A-Z]"
-    
-    it "generates a node for the lazily-instantiated character when it is the primary node" do
-      result = parse('A')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-  end
-
-end

data/spec/compiler/choice_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-module ChoiceSpec
-  describe "A choice between terminal symbols" 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_not be_nil
-      result.should respond_to(:foo_method)
-    
-      result = parse('bar')
-      result.should_not be_nil
-      result.should respond_to(:bar_method)
-    
-      result = parse('baz')
-      result.should_not be_nil
-      result.should respond_to(:baz_method)
-    end
-  
-    it "upon parsing a string matching the second alternative, records the failure of the first terminal" do
-      result = parse('bar')
-      terminal_failures = parser.terminal_failures
-      terminal_failures.size.should == 1
-      failure = terminal_failures[0]
-      failure.expected_string.should == 'foo'
-      failure.index.should == 0
-    end
-  
-    it "upon parsing a string matching the third alternative, records the failure of the first two terminals" do
-      result = parse('baz')
-      
-      terminal_failures = parser.terminal_failures
-      
-      terminal_failures.size.should == 2
-
-      failure_1 = terminal_failures[0]
-      failure_1.expected_string == 'foo'
-      failure_1.index.should == 0
-    
-      failure_2 = terminal_failures[1]
-      failure_2.expected_string == 'bar'
-      failure_2.index.should == 0
-    end
-  end
-
-  describe "A choice between sequences" do
-    testing_expression "'foo' 'bar' 'baz'\n/\n'bing' 'bang' 'boom'"
-
-    it "successfully parses input matching any of the alternatives" do
-      parse('foobarbaz').should_not be_nil
-      parse('bingbangboom').should_not be_nil
-    end
-  end
-
-  describe "A choice between terminals followed by a block" do  
-    testing_expression "('a'/ 'bb' / [c]) { def a_method; end }"
-
-    it "extends a match of any of its subexpressions with a module created from the block" do
-      ['a', 'bb', 'c'].each do |letter|
-        parse(letter).should respond_to(:a_method)
-      end
-    end
-  end
-
-  module TestModule
-    def a_method
-    end
-  end
-
-  describe "a choice followed by a declared module" do  
-    testing_expression "('a'/ 'bb' / [c]) <ChoiceSpec::TestModule>"
-
-    it "extends a match of any of its subexpressions with a module created from the block" do
-      ['a', 'bb', 'c'].each do |letter|
-        parse(letter).should respond_to(:a_method)
-      end
-    end
-  end
-end

data/spec/compiler/circular_compilation_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-BENCHMARK = false
-METAGRAMMAR_PATH = File.expand_path('../../../lib/treetop/compiler/metagrammar.treetop', __FILE__)
-
-module CircularCompilationSpec
-  describe "a parser for the metagrammar" do
-    attr_reader :parser
-    
-    before do
-      @parser = Treetop::Compiler::MetagrammarParser.new
-    end
-    
-    it "can parse the metagrammar.treetop whence it was generated" do
-      File.open(METAGRAMMAR_PATH, 'r') do |f|
-        metagrammar_source = f.read
-        result = parser.parse(metagrammar_source)
-        result.should_not be_nil
-
-        # generated_parser = result.compile
-        # Object.class_eval(generated_parser)
-        # parser_2 = Treetop::Compiler::MetagrammarParser.new
-        # optionally_benchmark do
-        #   result = parser_2.parse(metagrammar_source)
-        #   result.should_not be_nil
-        # end
-      end
-    end
-  end
-end

data/spec/compiler/failure_propagation_functional_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe "An expression for braces surrounding zero or more letters followed by semicolons" do
-  testing_expression "'{' ([a-z] ';')* '}'"
-  
-  it "parses matching input successfully" do
-    parse('{a;b;c;}').should_not be_nil
-  end
-  
-  it "fails to parse input with an expression that is missing a semicolon, reporting the terminal failure occurring at the maximum index" do
-    parse('{a;b;c}') do |result|
-      result.should be_nil
-      
-      terminal_failures = parser.terminal_failures
-      terminal_failures.size.should == 1      
-      failure = terminal_failures[0]
-      failure.index.should == 6
-      failure.expected_string.should == ';'
-    end
-  end
-end

data/spec/compiler/grammar_compiler_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-require 'tmpdir'
-
-describe Compiler::GrammarCompiler do
-  attr_reader :compiler, :source_path_with_treetop_extension, :source_path_with_tt_extension, :target_path, :alternate_target_path
-  before do
-    @compiler = Compiler::GrammarCompiler.new
-
-    dir = File.dirname(__FILE__)
-    @tmpdir = Dir.tmpdir
-
-    @source_path_with_treetop_extension = "#{dir}/test_grammar.treetop"
-    @source_path_with_do = "#{dir}/test_grammar_do.treetop"
-    @source_path_with_tt_extension = "#{dir}/test_grammar.tt"
-    @source_path_with_magic_coding = "#{dir}/test_grammar_magic_coding.treetop"
-    @source_path_with_magic_encoding = "#{dir}/test_grammar_magic_encoding.treetop"
-    @target_path = "#{@tmpdir}/test_grammar.rb"
-    @target_path_with_do = "#{@tmpdir}/test_grammar_do.rb"
-    @target_path_with_magic_coding = "#{@tmpdir}/test_grammar_magic_coding.rb"
-    @target_path_with_magic_encoding = "#{@tmpdir}/test_grammar_magic_encoding.rb"
-    @alternate_target_path = "#{@tmpdir}/test_grammar_alt.rb"
-    delete_target_files
-  end
-
-  after do
-    delete_target_files
-    Object.class_eval do
-      remove_const(:Test) if const_defined?(:Test)
-    end
-  end
-
-  specify "compilation of a single file to a default file name" do
-    src_copy = "#{@tmpdir}/test_grammar.treetop"
-    File.open(source_path_with_treetop_extension) { |f| File.open(src_copy,'w'){|o|o.write(f.read)} }
-    File.exists?(target_path).should be_false
-    compiler.compile(src_copy)
-    File.exists?(target_path).should be_true
-    require target_path
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-
-  specify "compilation of a single file to an explicit file name" do
-    File.exists?(alternate_target_path).should be_false
-    compiler.compile(source_path_with_treetop_extension, alternate_target_path)
-    File.exists?(alternate_target_path).should be_true
-    require alternate_target_path
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-
-  specify "compilation of a single file without writing it to an output file" do
-    compiler.ruby_source(source_path_with_treetop_extension).should_not be_nil
-  end
-  
-  specify "ruby_source_from_string compiles a grammar stored in string" do
-    compiler.ruby_source_from_string(File.read(source_path_with_treetop_extension)).should_not be_nil
-  end
-
-  specify "Treetop.load_from_string compiles and evaluates a source grammar stored in string" do
-    Treetop.load_from_string File.read(source_path_with_treetop_extension)
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-
-  specify "Treetop.load compiles and evaluates a source grammar with a .treetop extension" do    
-    Treetop.load source_path_with_treetop_extension
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-  
-  specify "Treetop.load compiles and evaluates a source grammar with a .tt extension" do
-    path_without_extension = source_path_with_tt_extension
-    Treetop.load path_without_extension
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-
-
-  specify "Treetop.load compiles and evaluates source grammar with no extension" do
-    path_without_extension = source_path_with_treetop_extension.gsub(/\.treetop\Z/, '')
-    Treetop.load path_without_extension
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-
-  specify "grammars with 'do' compile" do
-    src_copy = "#{@tmpdir}/test_grammar_do.treetop"
-    File.open(@source_path_with_do) { |f| File.open(src_copy,'w'){|o|o.write(f.read)} }
-    compiler.compile(src_copy)
-    require @target_path_with_do
-    Test::GrammarParser.new.parse('foo').should_not be_nil
-  end
-
-  specify "grammars with magic 'encoding' comments keep those comments at the top" do
-    src_copy = "#{@tmpdir}/test_grammar_magic_encoding.treetop"
-    File.open(@source_path_with_magic_encoding) do |f|
-      File.open(src_copy,'w'){|o|o.write(f.read)}
-    end
-    compiler.compile(src_copy)
-    File.open(@target_path_with_magic_encoding).readline.should == "# encoding: UTF-8\n"
-  end
-
-  specify "grammars with magic 'coding' comments keep those comments at the top" do
-    src_copy = "#{@tmpdir}/test_grammar_magic_coding.treetop"
-    File.open(@source_path_with_magic_coding) do |f|
-      File.open(src_copy,'w'){|o|o.write(f.read)}
-    end
-    compiler.compile(src_copy)
-    File.open(@target_path_with_magic_coding).readline.should == "# coding: UTF-8\n"
-  end
-
-  def delete_target_files
-    File.delete(target_path) if File.exists?(target_path)
-    File.delete(@target_path_with_do) if File.exists?(@target_path_with_do)
-    File.delete(alternate_target_path) if File.exists?(alternate_target_path)
-  end
-end
-

data/spec/compiler/grammar_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module GrammarSpec
-  module Bar
-  end
-
-  describe "a grammar" do
-    testing_grammar %{
-      grammar Foo
-              # This comment should not cause a syntax error, nor should the following empty one
-              #
-        include GrammarSpec::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_not be_nil
-      parse('bazbaz').should_not be_nil
-    end
-
-    it "fails if it does not parse all input" do
-      parse('barbarbazbaz').should be_nil
-    end
-
-    it "mixes in included modules" do
-      self.class.const_get(:Foo).ancestors.should include(GrammarSpec::Bar)
-    end
-  end
-end

data/spec/compiler/multibyte_chars_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module MultibyteCharsSpec
-  describe "an anything symbol", :multibyte => true do
-    testing_expression '.'
-    it "matches an UTF-8 character" do
-      parse_multibyte("ø").should_not be_nil
-    end
-  end
-
-  describe "A character class containing UTF-8 characters", :multibyte => true  do
-    testing_expression "[æøå]"
-    it "recognizes the UTF-8 characters" do
-      parse_multibyte("ø").should_not be_nil
-    end
-  end
-
-  describe( "a character class repetition containing UTF-8 characters mixed with other expressions",
-    :multibyte => true
-  ) do
-    testing_expression '[æøå]+ "a"'
-    it "lazily instantiates a node for the character" do
-      result = parse_multibyte('æøåa')
-      pending "Multibyte support is not supported in Ruby 1.8.6" if RUBY_VERSION =~ /^1\.8.6/
-      result.elements[0].instance_variable_get("@elements").should include(true)
-      result.elements[0].elements.should_not include(true)
-      result.elements[0].elements.size.should == 3
-      result.elements.size.should == 2
-      result.elements[0].text_value.should == "æøå"
-      result.elements[0].elements[0].text_value.should == "æ"
-      result.elements[0].elements[1].text_value.should == "ø"
-      result.elements[0].elements[2].text_value.should == "å"
-      result.elements[1].text_value == "a"
-    end
-  end
-end

data/spec/compiler/namespace_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-module NamespaceSpec
-
-  describe "a grammar" do
-    class_eval("module Foo; end")
-    testing_grammar %{
-      module Foo::Bar
-        module Baz
-          grammar Bat
-            rule foo
-              bar / baz
-            end
-
-            rule bar
-              'bar' 'bar'
-            end
-
-            rule baz
-              'baz' 'baz'
-            end
-          end
-        end
-      end
-    }
-
-    it "parses matching input" do
-      parse('barbar').should_not be_nil
-      parse('bazbaz').should_not be_nil
-    end
-
-    it "mixes in included modules" do
-      foo = self.class.const_get(:Foo)
-      bar = foo.const_get(:Bar)
-      baz = bar.const_get(:Baz)
-      baz.class.should == Module
-      bat = baz.const_get(:Bat)
-      bat.class.should == Module
-      baz.const_get(:BatParser).class.should == Class
-    end
-  end
-end