treetop 1.6.8 → 1.6.9

data/spec/compiler/occurrence_range_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-
-module OccurrenceRangeSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "zero to two of a terminal symbol followed by a node class declaration and a block" do
-    testing_expression '"foo"..2 <OccurrenceRangeSpec::Foo> { def a_method; end }'
-
-    it "successfully parses epsilon, reporting a 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 == 0
-      end
-    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 == 0
-      end
-    end
-
-    it "successfully parses one of that terminal, returning an instance of the declared node class and recording a terminal failure" do
-      parse("foo") 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 == 0
-      end
-    end
-
-    it "successfully parses two of that terminal, returning an instance of the declared node class and reporting no failure" do
-      parse("foofoo") 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 == 0
-      end
-    end
-
-    it "fails to parses two of that terminal but fails because of an extra one" do
-      parse("foofoofoo") do |result|
-        result.should be_nil
-
-        parser.terminal_failures.size.should == 1
-      end
-    end
-
-    it "parses two of three of that terminal, reporting no failure" do
-      parse("foofoofoo", :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.elements.size.should == 2
-
-        parser.terminal_failures.size.should == 0
-      end
-    end
-
-  end
-
-  describe "two to four of a terminal symbol followed by a node class declaration and a block" do
-    testing_expression '"foo" 2..4 <OccurrenceRangeSpec::Foo> { def a_method; end }'
-
-    it "fails to parse epsilon, reporting a failure" do
-      parse('') do |result|
-        result.should be_nil
-        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 "fails to parse one of that terminal, returning an instance of the declared node class and recording a terminal failure" do
-      parse("foo") do |result|
-        result.should be_nil
-
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-        failure = terminal_failures.first
-        failure.index.should == 3
-        failure.expected_string.should == '"foo"'
-      end
-    end
-
-    it "successfully parses two of that terminal, returning an instance of the declared node class and reporting no failure" do
-      parse("foofoo") 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 == 0
-      end
-    end
-
-    it "successfully parses four of that terminal, returning an instance of the declared node class and reporting no failure" do
-      parse("foofoofoofoo") 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 == 0
-      end
-    end
-
-    it "fails to parses four of that terminal because there's an extra unconsumed one" do
-      parse("foofoofoofoofoo") do |result|
-        result.should be_nil
-
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-  end
-
-  describe "two to any number of a terminal symbol followed by a node class declaration and a block" do
-    testing_expression '"foo" 2.. <OccurrenceRangeSpec::Foo> { def a_method; end }'
-
-    it "fails to parse epsilon, reporting a failure" do
-      parse('') do |result|
-        result.should be_nil
-        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 "fails to parse one of that terminal, returning an instance of the declared node class and recording a terminal failure" do
-      parse("foo") do |result|
-        result.should be_nil
-
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-        failure = terminal_failures.first
-        failure.index.should == 3
-        failure.expected_string.should == '"foo"'
-      end
-    end
-
-    it "successfully parses two of that terminal, returning an instance of the declared node class and reporting no failure" do
-      parse("foofoo") 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 == 6
-        failure.expected_string.should == '"foo"'
-      end
-    end
-
-    it "successfully parses four of that terminal, returning an instance of the declared node class and reporting a failure on the fifth" do
-      parse("foofoofoofoo") 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 == 12
-        failure.expected_string.should == '"foo"'
-      end
-    end
-  end
-
-end

data/spec/compiler/one_or_more_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module OneOrMoreSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "one or more of a terminal symbol followed by a node class declaration and a block" do
-    testing_expression '"foo"+ <OneOrMoreSpec::Foo> { def a_method; end }'
-
-    it "fails to parse epsilon, reporting a failure" do
-      parse('') do |result|
-        result.should be_nil
-        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 reporting the failure the third parsing attempt" do
-      parse("foofoo") 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 == 6
-        failure.expected_string.should == '"foo"'
-      end
-    end
-  end
-end

data/spec/compiler/optional_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-module OptionalSpec
-  describe "An optional terminal symbol" do
-    testing_expression '"foo"?'
-  
-    it "parses input matching the terminal" do
-      parse('foo').should_not be_nil
-    end
-  
-    it "parses epsilon, recording a failure" do
-      parse('') do |result|
-        result.should_not be_nil
-        result.interval.should == (0...0)
-        
-        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 "parses input not matching the terminal, returning an epsilon result and recording a failure" do
-      parse('bar', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.interval.should == (0...0)
-        
-        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
-  end
-end

data/spec/compiler/parenthesized_expression_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-module ParenthesizedExpressionSpec
-  describe "An unadorned expression inside of parentheses" do
-    testing_expression '("foo")'
-  
-    it "should behave as normal" do
-      parse('foo').should_not be_nil
-    end
-  end
-
-  describe "A prefixed-expression inside of parentheses" do
-    testing_expression '(!"foo")'
-  
-    it "should behave as normal" do
-      parse('foo') do |result|
-        result.should be_nil
-        parser.terminal_failures.size.should == 1
-      end
-    end
-  end
-
-  describe "An expression with code both inside and outside parentheses" do
-    testing_expression '("foo" { def inner; end } ) { def outer; end} '
-    it "should extend both code modules " do
-      parse('foo') do |result|
-        skip "Arbitrarily nested modules are not yet compiled"
-        result.should respond_to(:inner)
-        result.should respond_to(:outer)
-      end
-    end
-  end
-
-end

data/spec/compiler/parsing_rule_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-module ParsingRuleSpec
-  describe "a grammar with one parsing rule" do
-
-    testing_grammar %{
-      grammar Foo
-        rule bar
-          "baz"
-        end
-      end
-    }
-
-    it "stores and retrieves nodes in its node cache" do
-      parser = self.class.const_get(: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
-  
-  
-  describe "a grammar with choice that uses the cache and has a subsequent expression" do    
-    testing_grammar %{
-      grammar Logic
-        rule expression
-          value_plus
-          /
-          value
-        end
-
-        rule value_plus
-          value "something else"
-        end
-
-        rule value
-          [a-z]
-          /
-          "foobar" # the subsequent expression that needs cached.interval.end
-        end
-      end
-    }
-    
-    it "parses a single-character value and generates a node from the cache" do
-      result = parse('a')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-  end
-end

data/spec/compiler/repeated_subrule_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module RepeatedSubruleSpec
-  describe "a repeated subrule" do
-    testing_grammar %{
-      grammar Foo
-        rule foo
-          a:'a' space b:'b' space 'cc'
-        end
-
-        rule space
-          ' '
-        end
-      end
-    }
-  
-    it "should produce a parser having sequence-numbered node accessor methods" do
-      parse("a b cc") do |result|
-        result.should_not be_nil
-        result.should respond_to(:space1)
-        result.should respond_to(:space2)
-        result.should_not respond_to(:space)
-        result.should respond_to(:a)
-        result.should respond_to(:b)
-        result.should_not respond_to(:c)
-      end
-    end
-  end
-end

data/spec/compiler/semantic_predicate_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-module SemanticPredicateSpec
-  describe "An &-predicate block" do
-    testing_expression '& {|| $ok_to_succeed}'
-
-    it "succeeds if it returns true, returning an epsilon syntax node" do
-      $ok_to_succeed = true
-      parse('foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.interval.should == (0...0)
-      end
-    end
-
-    it "fails if it returns false" do
-      $ok_to_succeed = false
-      parse('foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-
-  end
-
-  describe "A sequence of a terminal and an &-predicate block" do
-    testing_expression '"prior " &{|s| $value = s[0].text_value; $ok_to_succeed }'
-
-    it "matches the input terminal and consumes it if the block returns true, seeing the terminal in the sequence" do
-      $ok_to_succeed = true
-      $value = nil
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.elements[0].text_value.should == "prior "
-        result.text_value.should == 'prior '
-        $value.should == 'prior '
-      end
-    end
-
-    it "fails if the block returns false, but sees the terminal in the sequence" do
-      $ok_to_succeed = false
-      $value = nil
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        $value.should == 'prior '
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-
-  end
-
-  describe "A sequence of an optional terminal and an &-predicate block" do
-    testing_expression '"prior "? &{|s| $value = s[0].text_value; $ok_to_succeed}'
-
-    it "matches the input terminal and consumes it if the block returns true" do
-      $ok_to_succeed = true
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.elements[0].text_value.should == "prior "
-        result.text_value.should == 'prior '
-        $value.should == 'prior '
-      end
-    end
-
-    it "fails with one terminal_failure if the block returns false" do
-      $ok_to_succeed = false
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        $value.should == 'prior '
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-
-    it "fail and return the expected optional preceeding terminal as expected input if the block returns false" do
-      $ok_to_succeed = false
-      parse('foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        terminal_failures = parser.terminal_failures
-        # We should get "prior " failed, and also the predicate block
-        terminal_failures.size.should == 2
-        terminal_failures[0].index.should == 0
-        terminal_failures[0].expected_string.should == '"prior "'
-        terminal_failures[1].index.should == 0
-        terminal_failures[1].expected_string.should == '<semantic predicate>'
-      end
-    end
-
-  end
-
-  describe "A !-predicate block" do
-    testing_expression '! {|| $ok_to_succeed}'
-
-    it "succeeds if it returns false, returning an epsilon syntax node" do
-      $ok_to_succeed = false
-      parse('foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.interval.should == (0...0)
-      end
-    end
-
-    it "fails if it returns true" do
-      $ok_to_succeed = true
-      parse('foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-
-  end
-
-  describe "A sequence of a terminal and an !-predicate block" do
-    testing_expression '"prior " !{|s| $value = s[0].text_value; $ok_to_succeed }'
-
-    it "matches the input terminal and consumes it if the block returns false, seeing the terminal in the sequence" do
-      $ok_to_succeed = false
-      $value = nil
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.elements[0].text_value.should == "prior "
-        result.text_value.should == 'prior '
-        $value.should == 'prior '
-      end
-    end
-
-    it "fails if the block returns true, but sees the terminal in the sequence" do
-      $ok_to_succeed = true
-      $value = nil
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        $value.should == 'prior '
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-
-  end
-
-  describe "A sequence of an optional terminal and an !-predicate block" do
-    testing_expression '"prior "? !{|s| $value = s[0].text_value; $ok_to_succeed}'
-
-    it "matches the input terminal and consumes it if the block returns false" do
-      $ok_to_succeed = false
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.elements[0].text_value.should == "prior "
-        result.text_value.should == 'prior '
-        $value.should == 'prior '
-      end
-    end
-
-    it "fails with one terminal_failure if the block returns true" do
-      $ok_to_succeed = true
-      parse('prior foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        $value.should == 'prior '
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-      end
-    end
-
-    it "fail and return the expected optional preceeding terminal as expected input if the block returns true" do
-      $ok_to_succeed = true
-      parse('foo', :consume_all_input => false) do |result|
-        result.should be_nil
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 2
-        terminal_failures[0].index.should == 0
-        terminal_failures[0].expected_string.should == '"prior "'
-      end
-    end
-
-  end
-end