treetop 1.4.5 → 1.4.7

data/spec/runtime/interval_skip_list/interval_skip_list_spec.rb

@@ -0,0 +1,58 @@
+#require 'runtime/interval_skip_list/spec_helper'
+#
+#MAX_INTERVAL = 100000
+#
+#describe IntervalSkipList do
+#  describe "#next_node_height" do
+#    attr_reader :list
+#
+#    before do
+#      @list = IntervalSkipList.new
+#    end
+#
+#    it "returns a number between 1 and the max_height of the list" do
+#      height = list.next_node_height
+#      height.should be <= list.max_height
+#      height.should be > 0
+#    end
+#  end
+#
+#  describe "a list with 1000 random intervals" do
+#    attr_reader :list, :inserted_ranges
+#
+#    before do
+#      @list = IntervalSkipList.new
+#      @inserted_ranges = []
+#
+#      0.upto(10) do |i|
+#        first, last = [rand(MAX_INTERVAL), rand(MAX_INTERVAL)].sort
+#        range = first..last
+#        list.insert(range, i)
+#        inserted_ranges.push(range)
+#      end
+#    end
+#
+#    it "functions correctly for stabbing queries" do
+#      10000.times do
+#        n = rand(MAX_INTERVAL)
+#        ranges = list.containing(n).sort
+#
+#        expected_ranges = []
+#        inserted_ranges.each_with_index do |range,i|
+#          expected_ranges.push(i) if n > range.first && n < range.last
+#        end
+#        expected_ranges.sort!
+#        unless ranges == expected_ranges
+#          puts "N = #{n}"
+#          puts "Expected: " + expected_ranges.inspect
+#          puts "Actual:   " + ranges.inspect
+#          expected_ranges.size.should be <= ranges.size
+#          puts "Missing containers: #{(expected_ranges.map {|o| o.object_id} - ranges.map {|o| o.object_id}).inspect}"
+#          puts "Unexpected containers: #{(ranges.map {|o| o.object_id} - expected_ranges.map {|o| o.object_id}).inspect}"
+#          puts "Inserted Ranges: #{inserted_ranges.inspect}"
+#          puts "Expected Ranges: #{expected_ranges.map {|i| inserted_ranges[i]}.inspect}"
+#        end
+#      end
+#    end
+#  end
+#end

data/spec/runtime/interval_skip_list/palindromic_fixture.rb

@@ -0,0 +1,23 @@
+describe "the palindromic fixture", :shared => true do
+  attr_reader :list, :node
+  include IntervalSkipListSpecHelper
+
+  before do
+    @list = IntervalSkipList.new
+  end
+
+  it_should_behave_like "#next_node_height is deterministic"
+  def expected_node_heights
+    [3, 2, 1, 3, 1, 2, 3]
+  end
+
+  before do
+    list.insert(1..3, :a)
+    list.insert(1..5, :b)
+    list.insert(1..7, :c)
+    list.insert(1..9, :d)
+    list.insert(1..11, :e)
+    list.insert(1..13, :f)
+    list.insert(5..13, :g)
+  end
+end

data/spec/runtime/interval_skip_list/palindromic_fixture_spec.rb

@@ -0,0 +1,163 @@
+require 'runtime/interval_skip_list/spec_helper'
+
+describe "The palindromic fixture" do
+  it_should_behave_like "the palindromic fixture"
+
+  describe " #nodes" do
+    describe "[0]" do
+      before do
+        @node = list.nodes[0]
+      end
+
+      it "has a key of 1 and a height of 3" do
+        node.key.should == 1
+        node.height.should == 3
+      end
+
+      it "has :c, :d, :e, and :f as its only forward markers at level 2" do
+        node.forward_markers[2].should have_markers(:c, :d, :e, :f)
+        end
+
+      it "has  :a, :b as its only forward markers at level 1" do
+        node.forward_markers[1].should have_markers(:a, :b)
+      end
+
+      it "has no forward markers at level 0" do
+        node.forward_markers[0].should be_empty
+      end
+
+      it "has no markers" do
+        node.markers.should be_empty
+      end
+    end
+
+    describe "[1]" do
+      before do
+        @node = list.nodes[1]
+      end
+
+      it "has a key of 3 and a height of 2" do
+        node.key.should == 3
+        node.height.should == 2
+      end
+
+      it "has no forward markers at level 1" do
+        node.forward_markers[1].should be_empty
+      end
+
+      it "has :b as its only forward marker at level 0" do
+        node.forward_markers[0].should have_marker(:b)
+      end
+
+      it "has :a and :b as its only markers" do
+        node.markers.should have_markers(:a, :b)
+      end
+    end
+
+    describe "[2]" do
+      before do
+        @node = list.nodes[2]
+      end
+
+      it "has a key of 5 and a height of 1" do
+        node.key.should == 5
+        node.height.should == 1
+      end
+
+      it "has :g as its only forward marker at level 0" do
+        node.forward_markers[0].should have_marker(:g)
+      end
+
+      it "has :b as its only marker" do
+        node.markers.should have_marker(:b)
+      end
+    end
+
+    describe "[3]" do
+      before do
+        @node = list.nodes[3]
+      end
+
+      it "has a key of 7 and a height of 3" do
+        node.key.should == 7
+        node.height.should == 3
+      end
+
+      it "has :f and :g as its only forward markers at level 2" do
+        node.forward_markers[2].should have_markers(:f, :g)
+      end
+
+      it "has :e as its only forward markers at level 1" do
+        node.forward_markers[1].should have_marker(:e)
+      end
+
+      it "has :d as its only forward marker at level 0" do
+        node.forward_markers[0].should have_markers(:d)
+      end
+
+      it "has :c, :d, :e, :f and :g as its only markers" do
+        node.markers.should have_markers(:c, :d, :e, :f, :g)
+      end
+    end
+
+    describe "[4]" do
+      before do
+        @node = list.nodes[4]
+      end
+
+      it "has a key of 9 and a height of 1" do
+        node.key.should == 9
+        node.height.should == 1
+      end
+
+      it "has no forward markers at any level" do
+        node.forward_markers[0].should be_empty
+      end
+
+      it "has :d as its only marker" do
+        node.markers.should have_markers(:d)
+      end
+    end
+
+    describe "[5]" do
+      before do
+        @node = list.nodes[5]
+      end
+
+      it "has a key of 11 and a height of 2" do
+        node.key.should == 11
+        node.height.should == 2
+      end
+
+      it "has no forward markers at any level" do
+        node.forward_markers[0].should be_empty
+        node.forward_markers[1].should be_empty
+      end
+
+      it "has :e as its only marker" do
+        node.markers.should have_markers(:e)
+      end
+    end
+
+    describe "[6]" do
+      before do
+        @node = list.nodes[6]
+      end
+
+      it "has a key of 13 and a height of 3" do
+        node.key.should == 13
+        node.height.should == 3
+      end
+
+      it "has no forward markers at any level" do
+        node.forward_markers[0].should be_empty
+        node.forward_markers[1].should be_empty
+        node.forward_markers[2].should be_empty
+      end
+
+      it "has :f and :g as its only markers" do
+        node.markers.should have_markers(:f, :g)
+      end
+    end
+  end
+end

data/spec/runtime/interval_skip_list/spec_helper.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+class IntervalSkipList
+  public :insert_node, :delete_node, :nodes, :head, :next_node_height
+end
+
+describe "#next_node_height is deterministic", :shared => true do
+  before do
+    node_heights = expected_node_heights.dup
+    stub(list).next_node_height { node_heights.shift }
+  end
+end
+
+module IntervalSkipListSpecHelper
+  def contain_marker(marker)
+    ContainMarkers.new(list, [marker])
+  end
+
+  def contain_markers(*markers)
+    ContainMarkers.new(list, markers)
+  end
+
+  class ContainMarkers
+    attr_reader :failure_message
+
+    def initialize(list, expected_markers)
+      @list = list
+      @expected_markers = expected_markers
+    end
+
+    def matches?(target_range)
+      @target_range = target_range
+
+      @target_range.each do |i|
+        markers = @list.containing(i)
+
+        @expected_markers.each do |expected_marker|
+          unless markers.include?(expected_marker)
+            @failure_message = "Expected #{expected_marker.inspect} to contain #{i}, but it doesn't. #{i} is contained by: #{markers.inspect}."
+            return false
+          end
+        end
+
+        markers.each do |marker|
+          unless @expected_markers.include?(marker)
+            @failure_message = "Did not expect #{marker.inspect} to contain #{i}. Only expected #{@expected_markers.inspect}."
+            return false
+          end
+        end
+      end
+
+      true
+    end
+  end
+
+  def have_markers(*markers)
+    HaveMarkers.new(markers)
+  end
+
+  def have_marker(marker)
+    HaveMarkers.new([marker])
+  end
+
+  class HaveMarkers
+    def initialize(expected_markers)
+      @expected_markers = expected_markers
+    end
+
+    def matches?(target)
+      @target = target
+      return false unless @target.size == @expected_markers.size
+      @expected_markers.each do |expected_marker|
+        return false unless @target.include?(expected_marker)
+      end
+      true
+    end
+
+    def failure_message
+      "Expected #{@target.inspect} to include only #{@expected_markers.inspect}"
+    end
+  end
+end
+
+require 'runtime/interval_skip_list/palindromic_fixture'

data/spec/runtime/syntax_node_spec.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,110 @@
+require 'rubygems'
+require 'benchmark'
+require 'spec'
+require 'polyglot'
+
+$LOAD_PATH.unshift File.expand_path('../../lib')
+require 'treetop'
+include Treetop
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+module Treetop
+  class TreetopExampleGroup < Spec::Example::ExampleGroup
+    class << self
+      attr_accessor :parser_class_under_test
+
+      def testing_expression(expression_under_test)
+        testing_grammar(%{
+          grammar Test
+            rule expression_under_test
+        }+expression_under_test+%{
+      end
+          end
+        }.tabto(0))
+      end
+
+      def testing_grammar(grammar_under_test)
+        grammar_node = parse_with_metagrammar(grammar_under_test.strip, :grammar)
+        parser_code = grammar_node.compile
+        class_eval(parser_code)
+        self.parser_class_under_test = const_get(grammar_node.parser_name.to_sym)
+      end
+
+      def parse_with_metagrammar(input, root)
+        parser = Treetop::Compiler::MetagrammarParser.new
+        parser.root = root
+        node = parser.parse(input)
+        raise parser.failure_reason unless node
+        node
+      end
+
+    end
+
+    attr_reader :parser
+
+    def parse_with_metagrammar(input, root)
+      self.class.parse_with_metagrammar(input, root)
+    end
+
+    def parser_class_under_test
+      self.class.parser_class_under_test
+    end
+
+    def parse(input, options = {})
+      @parser = parser_class_under_test.new
+      unless options[:consume_all_input].nil?
+        parser.consume_all_input = options.delete(:consume_all_input)
+      end
+      result = parser.parse(input, options)
+      yield result if block_given?
+      result
+    end
+
+    def parse_multibyte(input, options = {})
+      require 'active_support/all'
+      parse(input.mb_chars, options)
+    end
+
+    def compiling_grammar(grammar_under_test)
+      lambda {
+        grammar_node = parse_with_metagrammar(grammar_under_test.strip, :grammar)
+        parser_code = grammar_node.compile
+        [grammar_node, parser_code]
+      }
+    end
+
+    def compiling_expression(expression_under_test)
+      compiling_grammar(%{
+        grammar Test
+          rule expression_under_test
+            #{expression_under_test}
+          end
+        end
+      }.tabto(0))
+    end
+
+    def optionally_benchmark(&block)
+      if BENCHMARK
+        Benchmark.bm do |x|
+          x.report(&block)
+        end
+      else
+        yield
+      end
+    end
+
+    Spec::Example::ExampleGroupFactory.register(:compiler, self)
+    Spec::Example::ExampleGroupFactory.register(:runtime, self)
+  end
+end
+
+class Symbol
+  def to_proc
+    lambda do |x|
+      x.send(self)
+    end
+  end unless method_defined?(:to_proc)
+end