mail 2.1.5.2 → 2.1.5.3

data/lib/mail/vendor/treetop-1.4.4/lib/treetop/runtime/terminal_parse_failure.rb

@@ -1,16 +0,0 @@
-module Treetop
-  module Runtime
-    class TerminalParseFailure
-      attr_reader :index, :expected_string
-
-      def initialize(index, expected_string)
-        @index = index
-        @expected_string = expected_string
-      end
-
-      def to_s
-        "String matching #{expected_string} expected."
-      end
-    end
-  end
-end

data/lib/mail/vendor/treetop-1.4.4/lib/treetop/runtime/terminal_syntax_node.rb

@@ -1,17 +0,0 @@
-module Treetop
-  module Runtime
-    class TerminalSyntaxNode < SyntaxNode
-
-      def initialize(input, interval)
-        super(input, interval, [])
-      end
-
-      def inspect(indent="")
-	indent+
-	  self.class.to_s.sub(/.*:/,'') +
-	  " offset=#{interval.first}" +
-	  " #{text_value.inspect}"
-      end
-    end
-  end
-end

data/lib/mail/vendor/treetop-1.4.4/lib/treetop/version.rb

@@ -1,9 +0,0 @@
-module Treetop #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 4
-    TINY  = 4
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end

data/lib/mail/vendor/treetop-1.4.4/script/generate_metagrammar.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require File.expand_path('../../lib/treetop/bootstrap_gen_1_metagrammar', __FILE__)
-
-GENERATED_METAGRAMMAR_PATH = File.expand_path('../../lib/treetop/compiler/metagrammar.rb')
-
-File.open(METAGRAMMAR_PATH) do |source_file|
-  File.open(GENERATED_METAGRAMMAR_PATH, 'w') do |target_file|
-    generated_source = Treetop::Compiler::MetagrammarParser.new.parse(source_file.read).compile
-    target_file.write(generated_source)
-  end
-end

data/lib/mail/vendor/treetop-1.4.4/script/svnadd

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby -w
-
-def unversioned_files
-  `svn status`.
-    select { |line| line =~ /^\?/ }.
-    collect { |line| line[7..-1] }
-end
-
-unversioned_files.each do |file|
-  `svn add #{file}`
-end

data/lib/mail/vendor/treetop-1.4.4/script/svnrm

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby -w
-
-def missing_files
-  `svn status`.
-    select { |line| line =~ /^\!/ }.
-    collect { |line| line[7..-1] }
-end
-
-missing_files.each do |file|
-  `svn rm #{file}`
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-module AndPredicateSpec
-  describe "An &-predicated terminal symbol" do
-    testing_expression '&"foo"'
-
-    it "successfully parses input matching the terminal symbol, returning an epsilon syntax node" do
-      parse('foo', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.interval.should == (0...0)
-      end
-    end
-  end
-
-  describe "A sequence of a terminal and an and another &-predicated terminal" do
-    testing_expression '"foo" &"bar"'
-
-    it "matches input matching both terminals, but only consumes the first" do
-      parse('foobar', :consume_all_input => false) do |result|
-        result.should_not be_nil
-        result.text_value.should == 'foo'
-      end
-    end
-  
-    it "fails to parse input matching only the first terminal, with a terminal failure recorded at index 3" do
-      parse('foo') do |result|
-        result.should be_nil
-        terminal_failures = parser.terminal_failures
-        terminal_failures.size.should == 1
-        failure = terminal_failures[0]
-        failure.index.should == 3
-        failure.expected_string.should == 'bar'
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-module AnythingSymbolSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "an anything symbol followed by a node class declaration and a block" do
-    testing_expression '. <AnythingSymbolSpec::Foo> { def a_method; end }'
-  
-    it "matches any single character in a big range, returning an instance of the declared node class that responds to methods defined in the inline module" do
-      (33..127).each do |digit|
-        parse(digit.chr) do |result|
-          result.should_not be_nil
-          result.should be_an_instance_of(Foo)
-          result.should respond_to(:a_method)
-          result.interval.should == (0...1)
-        end
-      end
-    end
-  
-    it "fails to parse epsilon" do
-      parse('').should be_nil
-    end
-  end
-    
-  module ModFoo
-  end
-
-  describe "an anything symbol followed by a module declaration and a block" do
-    testing_expression '. <AnythingSymbolSpec::ModFoo> { def a_method; end }'
-  
-    it "matches any single character in a big range, returning an instance of SyntaxNode extended by the declared module that responds to methods defined in the inline module" do
-      (33..127).each do |digit|
-        parse(digit.chr) do |result|
-          result.should_not be_nil
-          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...1)
-        end
-      end
-    end
-  end
-end

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

@@ -1,276 +0,0 @@
-require 'spec_helper'
-
-module CharacterClassSpec
-  class Foo < Treetop::Runtime::SyntaxNode
-  end
-
-  describe "a character class followed by a node class declaration and a block" do
-
-    testing_expression "[A-Z] <CharacterClassSpec::Foo> { def a_method; end }"
-
-    it "matches single characters within that range, returning instances of the declared node class that respond to the method defined in the inline module" do
-      result = parse('A')
-      result.should be_an_instance_of(Foo)
-      result.should respond_to(:a_method)
-      result = parse('N')
-      result.should be_an_instance_of(Foo)
-      result.should respond_to(:a_method)
-      result = parse('Z')
-      result.should be_an_instance_of(Foo)
-      result.should respond_to(:a_method)
-    end
-
-    it "does not match single characters outside of that range" do
-      parse('8').should be_nil
-      parse('a').should be_nil
-    end
-
-    it "matches a single character within that range at index 1" do
-      parse(' A', :index => 1).should_not be_nil
-    end
-
-    it "fails to match a single character out of that range at index 1" do
-      parse(' 1', :index => 1).should be_nil
-    end
-  end
-
-  module ModFoo
-  end
-
-  describe "a character class followed by a node module declaration and a block" do
-
-    testing_expression "[A-Z] <CharacterClassSpec::ModFoo> { def a_method; end }"
-
-    it "matches single characters within that range, returning instances of SyntaxNode extended by the specified module" do
-      result = parse('A')
-      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-      result.should be_a_kind_of(ModFoo)
-      result.should respond_to(:a_method)
-      result = parse('N')
-      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-      result.should be_a_kind_of(ModFoo)
-      result.should respond_to(:a_method)
-      result = parse('Z')
-      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
-      result.should be_a_kind_of(ModFoo)
-      result.should respond_to(:a_method)
-    end
-
-    it "does not match single characters outside of that range" do
-      parse('8').should be_nil
-      parse('a').should be_nil
-    end
-
-    it "matches a single character within that range at index 1" do
-      parse(' A', :index => 1).should_not be_nil
-    end
-
-    it "fails to match a single character out of that range at index 1" do
-      parse(' 1', :index => 1).should be_nil
-    end
-  end
-  
-  describe "a character class followed by a node class declaration and a block" do
-
-    testing_expression "[A-Z] <CharacterClassSpec::Foo>"
-    
-    it "actively generates nodes for the character when it is the primary node" do
-      result = parse('A')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-    
-  end
-
-  describe "A character class containing quotes" do
-    testing_expression "[\"']"
-
-    it "matches a quote" do
-      parse("'").should_not be_nil
-    end
-
-    it "matches a double-quote" do
-      parse('"').should_not be_nil
-    end
-  end
-
-  describe "A character class containing a special character" do
-    testing_expression "[\t]"
-    it "matches that character only" do
-      parse("\t").should_not be_nil
-      parse('t').should be_nil
-    end
-  end
-
-  describe "A character class containing an escaped backslash" do
-    slash = "\\"  # Make it explicit that there are *two* backslashes here
-    testing_expression "[#{slash}#{slash}]"
-    it "matches a backslash only" do
-      parse("\\").should_not be_nil
-      parse('t').should be_nil
-    end
-  end
-
-  describe "A character class containing a hex escape" do
-    slash = "\\"
-    testing_expression "[#{slash}x41]"
-    it "matches that character only" do
-      parse('A').should_not be_nil
-      parse('\\').should be_nil
-      parse('x').should be_nil
-      parse('4').should be_nil
-      parse('1').should be_nil
-    end
-  end
-
-  describe "A character class containing an octal escape" do
-    slash = "\\"
-    testing_expression "[#{slash}101]"
-    it "matches that character only" do
-      parse('A').should_not be_nil
-      parse('\\').should be_nil
-      parse('1').should be_nil
-      parse('0').should be_nil
-    end
-  end
-
-  describe "A character class containing a \\c control-char escape" do
-    slash = "\\"
-    testing_expression "[#{slash}cC]"
-    it "matches that character only" do
-      parse("\003").should_not be_nil
-      parse('\\').should be_nil
-      parse('c').should be_nil
-      parse('C').should be_nil
-    end
-  end
-
-  describe "A character class containing a \\C- control-char escape" do
-    slash = "\\"
-    testing_expression "[#{slash}C-C]"
-    it "matches that character only" do
-      parse("\003").should_not be_nil
-      parse('\\').should be_nil
-      parse('C').should be_nil
-      parse('-').should be_nil
-    end
-  end
-
-  if RUBY_VERSION =~ /\A1\.8\./
-    describe "A character class containing a \\M- meta-char escape" do
-      slash = "\\"
-      testing_expression "[#{slash}M- ]"
-      it "matches that character only" do
-        parse("\240").should_not be_nil
-        parse('\\').should be_nil
-        parse('M').should be_nil
-        parse('-').should be_nil
-        parse(' ').should be_nil
-      end
-    end
-  end
-
-  describe "A character class containing an escaped non-special character" do
-    slash = "\\"
-    testing_expression "[#{slash}y]"
-    it "matches that character only" do
-      parse("y").should_not be_nil
-      parse('\\').should be_nil
-    end
-  end
-
-  describe "A character class containing an \#{...} insertion" do
-    testing_expression "[\#{raise 'error'}]"
-    it "doesn't evaluate the insertion" do
-      x = true
-      lambda{
-	x = parse("y")
-      }.should_not raise_error
-      x.should be_nil
-      parse('#').should_not be_nil
-      parse("'").should_not be_nil
-      parse("0").should be_nil
-    end
-  end
-  
-  describe "a character class" do
-    testing_expression "[A-Z]"
-    it "actively generates a node for the character because it is the primary node" do
-      result = parse('A')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-  end
-  
-  describe "a character class mixed with other expressions" do
-    testing_expression '[A-Z] "a"'
-    it "lazily instantiates a node for the character" do
-      result = parse('Aa')
-      result.instance_variable_get("@elements").should include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with a node class declaration mixed with other expressions" do
-    testing_expression '([A-Z] <CharacterClassSpec::Foo>) "a"'
-    it "actively generates a node for the character because it has a node class declared" do
-      result = parse('Aa')
-      result.instance_variable_get("@elements").should_not include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with a node module declaration mixed with other expressions" do
-    testing_expression '([A-Z] <CharacterClassSpec::ModFoo>) "a"'
-    it "actively generates a node for the character because it has a node module declared" do
-      result = parse('Aa')
-      result.instance_variable_get("@elements").should_not include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with an inline block mixed with other expressions" do
-    testing_expression '([A-Z] { def a_method; end }) "a"'
-    it "actively generates a node for the character because it has an inline block" do
-      result = parse('Aa')
-      result.instance_variable_get("@elements").should_not include(true)
-      result.elements.should_not include(true)
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class with a label mixed with other expressions" do
-    testing_expression 'upper:([A-Z]) "b"'
-    it "returns the correct element for the labeled expression" do
-      result = parse('Ab')
-      result.upper.text_value.should == "A"
-      result.elements.size.should == 2
-    end
-  end
-  
-  describe "a character class repetition mixed with other expressions" do
-    testing_expression '[A-Z]+ "a"'
-    it "lazily instantiates a node for the character" do
-      result = parse('ABCa')
-      result.elements[0].instance_variable_get("@elements").should include(true)
-      result.elements[0].elements.should_not include(true)
-      result.elements[0].elements.size.should == 3
-      result.elements.size.should == 2
-      result.elements.inspect.should == %Q{[SyntaxNode offset=0, "ABC":\n  SyntaxNode offset=0, "A"\n  SyntaxNode offset=1, "B"\n  SyntaxNode offset=2, "C", SyntaxNode offset=3, "a"]}
-    end
-  end
-  
-  describe "a character class that gets cached because of a choice" do
-    testing_expression "[A-Z] 'a' / [A-Z]"
-    
-    it "generates a node for the lazily-instantiated character when it is the primary node" do
-      result = parse('A')
-      result.should be_a(Treetop::Runtime::SyntaxNode)
-      result.elements.should be_nil
-    end
-  end
-
-end

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

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-module ChoiceSpec
-  describe "A choice between terminal symbols" do
-    testing_expression '"foo" { def foo_method; end } / "bar" { def bar_method; end } / "baz" { def baz_method; end }'
-
-    it "successfully parses input matching any of the alternatives, returning a node that responds to methods defined in its respective inline module" do
-      result = parse('foo')
-      result.should_not be_nil
-      result.should respond_to(:foo_method)
-    
-      result = parse('bar')
-      result.should_not be_nil
-      result.should respond_to(:bar_method)
-    
-      result = parse('baz')
-      result.should_not be_nil
-      result.should respond_to(:baz_method)
-    end
-  
-    it "upon parsing a string matching the second alternative, records the failure of the first terminal" do
-      result = parse('bar')
-      terminal_failures = parser.terminal_failures
-      terminal_failures.size.should == 1
-      failure = terminal_failures[0]
-      failure.expected_string.should == 'foo'
-      failure.index.should == 0
-    end
-  
-    it "upon parsing a string matching the third alternative, records the failure of the first two terminals" do
-      result = parse('baz')
-      
-      terminal_failures = parser.terminal_failures
-      
-      terminal_failures.size.should == 2
-
-      failure_1 = terminal_failures[0]
-      failure_1.expected_string == 'foo'
-      failure_1.index.should == 0
-    
-      failure_2 = terminal_failures[1]
-      failure_2.expected_string == 'bar'
-      failure_2.index.should == 0
-    end
-  end
-
-  describe "A choice between sequences" do
-    testing_expression "'foo' 'bar' 'baz'\n/\n'bing' 'bang' 'boom'"
-
-    it "successfully parses input matching any of the alternatives" do
-      parse('foobarbaz').should_not be_nil
-      parse('bingbangboom').should_not be_nil
-    end
-  end
-
-  describe "A choice between terminals followed by a block" do  
-    testing_expression "('a'/ 'b' / 'c') { def a_method; end }"
-
-    it "extends a match of any of its subexpressions with a module created from the block" do
-      ['a', 'b', 'c'].each do |letter|
-        parse(letter).should respond_to(:a_method)
-      end
-    end
-  end
-
-  module TestModule
-    def a_method
-    end
-  end
-
-  describe "a choice followed by a declared module" do  
-    testing_expression "('a'/ 'b' / 'c') <ChoiceSpec::TestModule>"
-
-    it "extends a match of any of its subexpressions with a module created from the block" do
-      ['a', 'b', 'c'].each do |letter|
-        parse(letter).should respond_to(:a_method)
-      end
-    end
-  end
-end