personify 1.0.0 → 1.1.0

data/vendor/treetop/spec/compiler/sequence_spec.rb

@@ -1,115 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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 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/vendor/treetop/spec/compiler/terminal_spec.rb

@@ -1,81 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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
-
-  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 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/vendor/treetop/spec/compiler/terminal_symbol_spec.rb

@@ -1,37 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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/vendor/treetop/spec/compiler/test_grammar.treetop

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

data/vendor/treetop/spec/compiler/test_grammar.tt

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

data/vendor/treetop/spec/compiler/test_grammar_do.treetop

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

data/vendor/treetop/spec/compiler/zero_or_more_spec.rb

@@ -1,56 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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" / "b")*'
-
-    it "successfully parses matching input" do
-      parse('abba').should_not be_nil
-    end
-  end
-end

data/vendor/treetop/spec/composition/a.treetop

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

data/vendor/treetop/spec/composition/b.treetop

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

data/vendor/treetop/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/vendor/treetop/spec/composition/d.treetop

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

data/vendor/treetop/spec/composition/grammar_composition_spec.rb

@@ -1,26 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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('abc').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
-end

data/vendor/treetop/spec/ruby_extensions/string_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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/vendor/treetop/spec/runtime/compiled_parser_spec.rb

@@ -1,101 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../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
-          'b'
-        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
-      
-      parser.root = :b
-      parser.parse('b').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
-      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
-    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) after "
-      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
-end

data/vendor/treetop/spec/runtime/interval_skip_list/delete_spec.rb

@@ -1,147 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
-
-class IntervalSkipList
-  public :insert_node, :delete_node, :head, :nodes
-end
-
-describe IntervalSkipList do
-  it_should_behave_like "the palindromic fixture"
-
-  describe " when :c is deleted" do
-    before do
-      list.delete(:c)
-    end
-
-    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 :f as its only forward marker at level 2" do
-        node.forward_markers[2].should have_markers(:f)
-        end
-
-      it "has :a, :b, :d, and :e as its only forward markers at level 1" do
-        node.forward_markers[1].should have_markers(:a, :b, :d, :e)
-      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 :e as its only forward marker at level 1" do
-        node.forward_markers[1].should have_markers(:e)
-      end
-
-      it "has :b and :d as its only forward markers at level 0" do
-        node.forward_markers[0].should have_markers(:b, :d)
-      end
-
-      it "has :a, :b, :d, and :e as its only markers" do
-        node.markers.should have_markers(:a, :b, :d, :e)
-      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 :d and :g as its only forward markers at level 0" do
-        node.forward_markers[0].should have_markers(:d, :g)
-      end
-
-      it "has :b and :d as its only markers" do
-        node.markers.should have_markers(:b, :d)
-      end
-    end
-
-    describe "[3]" do
-      before do
-        @node = list.nodes[3]
-      end
-
-      it "has a key of 9 and a height of 1" do
-        node.key.should == 9
-        node.height.should == 1
-      end
-
-      it "has :g as its only forward marker at level 0" do
-        node.forward_markers[0].should have_markers(:g)
-      end
-
-      it "has :d and :g as its only markers" do
-        node.markers.should have_markers(:d, :g)
-      end
-    end
-
-    describe "[4]" do
-      before do
-        @node = list.nodes[4]
-      end
-
-      it "has a key of 11 and a height of 2" do
-        node.key.should == 11
-        node.height.should == 2
-      end
-
-      it "has :g as its only forward marker at level 1" do
-        node.forward_markers[1].should have_markers(:g)
-      end
-
-      it "has no forward markers at level 0" do
-        node.forward_markers[0].should be_empty
-      end
-
-      it "has :e and :g as its only markers" do
-        node.markers.should have_markers(:e, :g)
-      end
-    end
-
-    describe "[5]" do
-      before do
-        @node = list.nodes[5]
-      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