treetop 1.6.6 → 1.6.11

data/spec/compiler/zero_or_more_spec.rb

@@ -1,58 +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" { def b_method; end } )* <ZeroOrMoreSpec::Foo> { def a_method; end }'
-    # testing_expression '("foo" { def a_method; end } )* <ZeroOrMoreSpec::Foo>'
-    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

data/spec/composition/c.treetop

@@ -1,10 +0,0 @@
-module Test
-  grammar C
-    include A
-    include B
-    
-    rule c
-      a b 'c'
-    end
-  end
-end

data/spec/composition/d.treetop

@@ -1,10 +0,0 @@
-module Test
-  grammar D
-    include A
-    include B
-    
-    rule inherit
-      super 'works'
-    end
-  end
-end

data/spec/composition/f.treetop

@@ -1,17 +0,0 @@
-
-require "a"
-
-require	File.dirname(__FILE__) + "/b"
-require File.dirname(__FILE__) + "/subfolder/e_includes_c"
-
-module Test
-  grammar F
-    include A
-    include B
-    include E
-    
-    rule f
-      c e 'f'
-    end
-  end
-end

data/spec/composition/grammar_composition_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-module GrammarCompositionSpec
-  describe "several composed grammars" do
-    before do
-      dir = File.dirname(__FILE__)
-      Treetop.load File.join(dir, 'a')
-      Treetop.load File.join(dir, 'b')
-      Treetop.load File.join(dir, 'c')
-      # Check that polyglot finds d.treetop and loads it:
-      $: << dir
-      require 'd'
-  
-      @c = ::Test::CParser.new
-      @d = ::Test::DParser.new
-    end
-
-    specify "rules in C have access to rules defined in A and B" do
-      @c.parse('abbc').should_not be_nil
-    end
-
-    specify "rules in C can override rules in A and B with super semantics" do
-      @d.parse('superkeywordworks').should_not be_nil
-    end
-  end
-  
-  describe "composed grammar chaining with require" do
-    before do
-      # Load f with polyglot without using the load path:
-      require File.dirname(__FILE__) + '/f'
-  
-      @f = ::Test::FParser.new
-    end
-    
-    specify "rules in F have access to rule defined in E" do
-      @f.parse('abbcef').should_not be_nil
-    end
-    
-  end
-end

data/spec/composition/subfolder/e_includes_c.treetop

@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + "/../c"
-
-module Test
-  grammar E
-    include C
-    
-    rule e
-      'e'
-    end
-    
-    rule inherit
-      'super'
-    end
-  end
-end

data/spec/ruby_extensions/string_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe String do
-  before do
-    @string = %{
-      0123456789
-      012345
-      01234567
-      0123
-    }.tabto(0).strip
-  end
-  
-  it "can translate indices to column numbers" do
-    @string.column_of(0).should == 1
-    @string.column_of(5).should == 6
-    @string.column_of(10).should == 11
-    @string.column_of(11).should == 1
-    @string.column_of(17).should == 7
-    @string.column_of(18).should == 1
-    @string.column_of(24).should == 7
-  end
-  
-  it "can translate indices to line numbers" do
-    @string.line_of(0).should == 1
-    @string.line_of(5).should == 1
-    @string.line_of(10).should == 1
-    @string.line_of(11).should == 2
-    @string.line_of(17).should == 2
-    @string.line_of(18).should == 3
-    @string.line_of(24).should == 3
-  end
-end

data/spec/runtime/compiled_parser_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-
-module CompiledParserSpec
-  describe Runtime::CompiledParser, "for a grammar with two rules" do
-    attr_reader :parser
-
-    testing_grammar %{
-      grammar TwoRules
-        rule a
-          'a'
-        end
-
-        rule b
-          'bb'
-        end
-      end
-    }
-
-    before do
-      @parser = parser_class_under_test.new
-    end
-
-    it "allows its root to be specified" do
-      parser.parse('a').should_not be_nil
-      parser.parse('b').should be_nil
-
-      # Check that the temporary-override works:
-      parser.parse('bb', :root => :b).should_not be_nil
-      parser.parse('a', :root => :b).should be_nil
-
-      # Check that the temporary-override isn't sticky:
-      parser.parse('a').should_not be_nil
-
-      # Try a permanent override:
-      parser.root = :b
-      parser.parse('bb').should_not be_nil
-      parser.parse('a').should be_nil
-    end
-
-    it "allows the requirement that all input be consumed to be disabled" do
-      parser.parse('ab').should be_nil
-
-      # Try a temporary override, and check it's not sticky:
-      result = parser.parse('ab', :consume_all_input => false)
-      result.should_not be_nil
-      result.interval.should == (0...1)
-      parser.parse('ab').should be_nil
-
-      # Now a permanent override:
-      parser.consume_all_input = false
-      result = parser.parse('ab')
-      result.should_not be_nil
-      result.interval.should == (0...1)
-    end
-
-    it "allows input to be parsed at a given index" do
-      parser.parse('ba').should be_nil
-      parser.parse('ba', :index => 1).should_not be_nil
-      # Check that the index defaults again to zero:
-      parser.parse('a').should_not be_nil
-
-      result = parser.parse('ba', :consume_all_input => false, :index => 1)
-      result.should_not be_nil
-      result.interval.should == (1...2)
-    end
-
-  end
-
-  describe Runtime::CompiledParser, "for a grammar with a choice between terminals" do
-    attr_reader :parser
-
-    testing_grammar %{
-      grammar Choice
-        rule choice
-          'a' / 'b' / 'c'
-        end
-      end
-    }
-
-    before do
-      @parser = parser_class_under_test.new
-    end
-
-    it "provides #failure_reason, #failure_column, and #failure_line when there is a parse failure" do
-      parser.parse('z').should be_nil
-      parser.failure_reason.should == "Expected one of 'a', 'b', 'c' at line 1, column 1 (byte 1)"
-      parser.failure_line.should == 1
-      parser.failure_column.should == 1
-    end
-  end
-
-  describe Runtime::CompiledParser,  "#terminal_failures" do
-    attr_reader:parser
-
-    testing_grammar %{
-      grammar SequenceOfTerminals
-        rule foo
-          'a' 'b' 'c'
-        end
-      end
-    }
-
-    before do
-      @parser = parser_class_under_test.new
-    end
-
-    it "is reset between parses" do
-      parser.parse('ac')
-      terminal_failures = parser.terminal_failures
-      terminal_failures.size.should == 1
-      failure = terminal_failures.first
-      failure.index.should == 1
-      failure.expected_string.should == "'b'"
-
-      parser.parse('b')
-      terminal_failures = parser.terminal_failures
-      terminal_failures.size.should == 1
-      failure = terminal_failures.first
-      failure.index.should == 0
-      failure.expected_string.should == "'a'"
-    end
-  end
-
-  describe "a SyntaxNode" do
-    attr_reader :parser
-
-    testing_grammar %{
-      grammar Alternates
-        rule main
-          aa &{|s| s[0].elements[0].parent.should == s[0] }
-          / ab &{|s| s[0].elements[0].parent.should == s[0] }
-        end
-
-        rule aa
-          'a' 'a'
-        end
-
-        rule ab
-          'a' 'b'
-        end
-      end
-    }
-
-    before do
-      @parser = parser_class_under_test.new
-    end
-
-    it "should have its parent set and reset" do
-      parser.parse('ab')
-    end
-  end
-
-end

data/spec/runtime/syntax_node_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-module SyntaxNodeSpec
-  describe "A new terminal syntax node" do
-    attr_reader :node
-
-    before do
-      @node = Runtime::SyntaxNode.new("input", 0...3)
-    end
-  
-    it "reports itself as terminal" do
-      node.should be_terminal
-      node.should_not be_nonterminal
-    end
-  
-    it "has a text value based on the input and the interval" do
-      node.text_value.should == "inp"
-    end
-  
-    it "has itself as its only element" do
-      node.elements.should be_nil
-    end
-  end
-
-  describe "A new nonterminal syntax node" do
-    attr_reader :node
-
-    before do
-      @elements = [Runtime::SyntaxNode.new('input', 0...3)]
-      @node = Runtime::SyntaxNode.new('input', 0...3, @elements)
-    end
-
-    it "reports itself as nonterminal" do
-      node.should be_nonterminal
-      node.should_not be_terminal
-    end
-  
-    it "has a text value based on the input and the interval" do
-      node.text_value.should == "inp"
-    end
-  
-    it "has the elements with which it was instantiated" do
-      node.elements.should == @elements
-    end
-
-    it "sets itself as the parent of its elements" do
-      node.elements.each do |element|
-        element.parent.should == node
-      end
-    end
-  end
-  
-  describe "A new nonterminal syntax node with all children lazily instantiated" do
-    attr_reader :node
-    
-    it "should lazily instantiate its child nodes" do
-      @node = Runtime::SyntaxNode.new('input', 0...3, [true, true, true])
-      node.elements.size.should == 3
-      node.elements.first.interval.should == (0...1)
-      node.elements.first.parent.should == node
-    end
-    
-    it "should lazily replace stand-in child nodes around real ones" do
-      @input = "input"
-      child1 = Runtime::SyntaxNode.new(@input, 1...2)
-      child2 = Runtime::SyntaxNode.new(@input, 3...4)
-      @node = Runtime::SyntaxNode.new(@input, 0...5, [true, child1, true, child2, true])
-      node.elements.size.should == 5
-      
-      node.elements[0].interval.should == (0...1)
-      node.elements[0].parent.should == node
-      0.upto(4) do |index|
-        node.elements[index].text_value.should == @input[index, 1]
-      end
-    end
-  end
-end