mail 2.1.5.2 → 2.1.5.3

data/lib/mail/vendor/treetop-1.4.4/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 'c'
-        end
-
-        rule space
-          ' '
-        end
-      end
-    }
-  
-    it "should produce a parser having sequence-numbered node accessor methods" do
-      parse("a b c") 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/lib/mail/vendor/treetop-1.4.4/spec/compiler/semantic_predicate_spec.rb

@@ -1,175 +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 == 0
-      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 == 0
-      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 no terminal_failures 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 == 0
-      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
-        terminal_failures.size.should == 1
-        failure = terminal_failures[0]
-        failure.index.should == 0
-        failure.expected_string.should == 'prior '
-      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 == 0
-      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 == 0
-      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 no terminal_failures 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 == 0
-      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 == 1
-        failure = terminal_failures[0]
-        failure.index.should == 0
-        failure.expected_string.should == 'prior '
-      end
-    end
-
-  end
-end

data/lib/mail/vendor/treetop-1.4.4/spec/compiler/sequence_spec.rb

@@ -1,115 +0,0 @@
-require '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/lib/mail/vendor/treetop-1.4.4/spec/compiler/terminal_spec.rb

@@ -1,81 +0,0 @@
-require '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/lib/mail/vendor/treetop-1.4.4/spec/compiler/terminal_symbol_spec.rb

@@ -1,37 +0,0 @@
-require '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/lib/mail/vendor/treetop-1.4.4/spec/compiler/test_grammar.treetop

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