rack-mail_exception 0.0.1

data/vendor/mail/spec/mail/parts_list_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe "PartsList" do
+  it "should return itself on sort" do
+    p = Mail::PartsList.new
+    p << 2
+    p << 1
+    p.sort.class.should == Mail::PartsList
+  end
+end

data/vendor/mail/spec/mail/round_tripping_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "Round Tripping" do
+
+  it "should round trip a basic email" do
+    mail = Mail.new('Subject: FooBar')
+    mail.body "This is Text"
+    parsed_mail = Mail.new(mail.to_s)
+    parsed_mail.subject.to_s.should == "FooBar"
+    parsed_mail.body.to_s.should == "This is Text"
+  end
+
+  it "should round trip a html multipart email" do
+    mail = Mail.new('Subject: FooBar')
+    mail.text_part = Mail::Part.new do
+      body "This is Text"
+    end
+    mail.html_part = Mail::Part.new do
+      content_type = "text/html; charset=US-ASCII"
+      body "<b>This is HTML</b>"
+    end
+    parsed_mail = Mail.new(mail.to_s)
+    parsed_mail.mime_type.should == 'multipart/alternative'
+    parsed_mail.boundary.should == mail.boundary
+    parsed_mail.parts.length.should == 2
+    parsed_mail.parts[0].body.to_s.should == "This is Text"
+    parsed_mail.parts[1].body.to_s.should == "<b>This is HTML</b>"
+  end
+
+  it "should round trip an email" do
+    initial = Mail.new do
+      to        "mikel@test.lindsaar.net"
+      subject   "testing round tripping"
+      body      "Really testing round tripping."
+      from      "system@test.lindsaar.net"
+      cc        "nobody@test.lindsaar.net"
+      bcc       "bob@test.lindsaar.net"
+      date      Time.local(2009, 11, 6)
+    end
+    Mail.new(initial.encoded).encoded.should == initial.encoded
+  end
+
+end

data/vendor/mail/spec/mail/utilities_spec.rb

@@ -0,0 +1,327 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "Utilities Module" do
+
+  include Mail::Utilities
+
+  describe "token safe" do
+    
+    describe "checking" do
+      it "should return true if a string is token safe" do
+        token_safe?('.abc').should be_true
+      end
+
+      it "should return false if a string is token safe" do
+        token_safe?('?=abc').should be_false
+      end
+
+      it "should work with mb_chars" do
+        token_safe?('.abc'.mb_chars).should be_true
+        token_safe?('?=abc'.mb_chars).should be_false
+      end
+    end
+
+    describe "quoting" do
+      it "should return true if a string is token safe" do
+        quote_token('.abc').should == '.abc'
+      end
+
+      it "should return false if a string is token safe" do
+        quote_token('?=abc').should == '"?=abc"'
+      end
+
+      it "should work with mb_chars" do
+        quote_token('.abc'.mb_chars).should == '.abc'
+        quote_token('?=abc'.mb_chars).should == '"?=abc"'
+      end
+    end
+
+  end
+
+  describe "atom safe" do
+    
+    describe "checking" do
+      it "should return true if a string is token safe" do
+        atom_safe?('?=abc').should be_true
+      end
+
+      it "should return false if a string is token safe" do
+        atom_safe?('.abc').should be_false
+      end
+
+      it "should work with mb_chars" do
+        atom_safe?('?=abc'.mb_chars).should be_true
+        atom_safe?('.abc'.mb_chars).should be_false
+      end
+    end
+
+    describe "quoting" do
+      it "should return true if a string is token safe" do
+        quote_atom('?=abc').should == '?=abc'
+      end
+
+      it "should return false if a string is token safe" do
+        quote_atom('.abc').should == '".abc"'
+      end
+
+      it "should work with mb_chars" do
+        quote_atom('?=abc'.mb_chars).should == '?=abc'
+        quote_atom('.abc'.mb_chars).should == '".abc"'
+      end
+
+      it "should work with mb_chars" do
+        quote_atom('?=abc'.mb_chars).should == '?=abc'
+        quote_atom('.abc'.mb_chars).should == '".abc"'
+      end
+      
+      it "should quote white space" do
+        quote_atom('ab abc'.mb_chars).should == '"ab abc"'
+        quote_atom("ab\ta\r\nbc".mb_chars).should == %{"ab\ta\r\nbc"}
+      end
+    end
+
+  end
+
+  describe "escaping parenthesies" do
+    it "should escape parens" do
+      test = 'This is not (escaped)'
+      result = 'This is not \(escaped\)'
+      escape_paren(test).should == result
+    end
+
+    it "should not double escape parens" do
+      test = 'This is not \(escaped\)'
+      result = 'This is not \(escaped\)'
+      escape_paren(test).should == result
+    end
+
+    it "should escape all parens" do
+      test = 'This is not \()escaped(\)'
+      result = 'This is not \(\)escaped\(\)'
+      escape_paren(test).should == result
+    end
+    
+  end
+  
+  describe "unescaping parenthesis" do
+
+    it "should work" do
+      test = '(This is a string)'
+      result = 'This is a string'
+      unparen(test).should == result
+    end
+
+    it "should work without parens" do
+      test = 'This is a string'
+      result = 'This is a string'
+      unparen(test).should == result
+    end
+
+    it "should work using ActiveSupport mb_chars" do
+      test = '(This is a string)'.mb_chars
+      result = 'This is a string'
+      unparen(test).should == result
+    end
+
+    it "should work without parens using ActiveSupport mb_chars" do
+      test = 'This is a string'.mb_chars
+      result = 'This is a string'
+      unparen(test).should == result
+    end
+
+  end
+  
+  describe "unescaping brackets" do
+
+    it "should work" do
+      test = '<This is a string>'
+      result = 'This is a string'
+      unbracket(test).should == result
+    end
+
+    it "should work without brackets" do
+      test = 'This is a string'
+      result = 'This is a string'
+      unbracket(test).should == result
+    end
+
+    it "should work using ActiveSupport mb_chars" do
+      test = '<This is a string>'.mb_chars
+      result = 'This is a string'
+      unbracket(test).should == result
+    end
+
+    it "should work without parens using ActiveSupport mb_chars" do
+      test = 'This is a string'.mb_chars
+      result = 'This is a string'
+      unbracket(test).should == result
+    end
+
+  end
+  
+  describe "quoting phrases" do
+    it "should quote a phrase if it is unsafe" do
+      test = 'this.needs quoting'
+      result = '"this.needs quoting"'
+      dquote(test).should == result
+    end
+
+    it "should properly quote a string, even if quoted but not escaped properly" do
+      test = '"this needs "escaping"'
+      result = '"this needs \"escaping"'
+      dquote(test).should == result
+    end
+    
+    it "should quote correctly a phrase with an escaped quote in it" do
+      test = 'this needs \"quoting'
+      result = '"this needs \"quoting"'
+      dquote(test).should == result
+    end
+    
+    it "should quote correctly a phrase with an escaped backslash followed by an escaped quote in it" do
+      test = 'this needs \\\"quoting'
+      result = '"this needs \\\"quoting"'
+      dquote(test).should == result
+    end
+  end
+  
+  
+  describe "parenthesizing phrases" do
+    it "should parenthesize a phrase" do
+      test = 'this.needs parenthesizing'
+      result = '(this.needs parenthesizing)'
+      paren(test).should == result
+    end
+
+    it "should properly parenthesize a string, and escape properly" do
+      test = 'this needs (escaping'
+      result = '(this needs \(escaping)'
+      paren(test).should == result
+    end
+
+    it "should properly parenthesize a string, and escape properly (other way)" do
+      test = 'this needs )escaping'
+      result = '(this needs \)escaping)'
+      paren(test).should == result
+    end
+
+    it "should properly parenthesize a string, even if parenthesized but not escaped properly" do
+      test = '(this needs (escaping)'
+      result = '(this needs \(escaping)'
+      paren(test).should == result
+    end
+
+    it "should properly parenthesize a string, even if parenthesized but not escaped properly (other way)" do
+      test = '(this needs )escaping)'
+      result = '(this needs \)escaping)'
+      paren(test).should == result
+    end
+    
+    it "should parenthesize correctly a phrase with an escaped parentheses in it" do
+      test = 'this needs \(parenthesizing'
+      result = '(this needs \(parenthesizing)'
+      paren(test).should == result
+    end
+    
+    it "should parenthesize correctly a phrase with an escaped parentheses in it (other way)" do
+      test = 'this needs \)parenthesizing'
+      result = '(this needs \)parenthesizing)'
+      paren(test).should == result
+    end
+    
+    it "should parenthesize correctly a phrase with an escaped backslash followed by an escaped parentheses in it" do
+      test = 'this needs \\\(parenthesizing'
+      result = '(this needs \\\(parenthesizing)'
+      paren(test).should == result
+    end
+    
+    it "should parenthesize correctly a phrase with an escaped backslash followed by an escaped parentheses in it (other way)" do
+      test = 'this needs \\\)parenthesizing'
+      result = '(this needs \\\)parenthesizing)'
+      paren(test).should == result
+    end
+
+    it "should parenthesize correctly a phrase with a set of parentheses" do
+      test = 'this (needs) parenthesizing'
+      result = '(this \(needs\) parenthesizing)'
+      paren(test).should == result
+    end
+    
+  end
+  
+  
+  describe "bracketizing phrases" do
+    it "should bracketize a phrase" do
+      test = 'this.needs bracketizing'
+      result = '<this.needs bracketizing>'
+      bracket(test).should == result
+    end
+
+    it "should properly bracketize a string, and escape properly" do
+      test = 'this needs <escaping'
+      result = '<this needs \<escaping>'
+      bracket(test).should == result
+    end
+
+    it "should properly bracketize a string, and escape properly (other way)" do
+      test = 'this needs >escaping'
+      result = '<this needs \>escaping>'
+      bracket(test).should == result
+    end
+
+    it "should properly bracketize a string, even if bracketized but not escaped properly" do
+      test = '<this needs <escaping>'
+      result = '<this needs \<escaping>'
+      bracket(test).should == result
+    end
+
+    it "should properly bracketize a string, even if bracketized but not escaped properly (other way)" do
+      test = '<this needs >escaping>'
+      result = '<this needs \>escaping>'
+      bracket(test).should == result
+    end
+    
+    it "should bracketize correctly a phrase with an escaped brackets in it" do
+      test = 'this needs \<bracketizing'
+      result = '<this needs \<bracketizing>'
+      bracket(test).should == result
+    end
+    
+    it "should bracketize correctly a phrase with an escaped brackets in it (other way)" do
+      test = 'this needs \>bracketizing'
+      result = '<this needs \>bracketizing>'
+      bracket(test).should == result
+    end
+    
+    it "should bracketize correctly a phrase with an escaped backslash followed by an escaped brackets in it" do
+      test = 'this needs \\\<bracketizing'
+      result = '<this needs \\\<bracketizing>'
+      bracket(test).should == result
+    end
+    
+    it "should bracketize correctly a phrase with an escaped backslash followed by an escaped brackets in it (other way)" do
+      test = 'this needs \\\>bracketizing'
+      result = '<this needs \\\>bracketizing>'
+      bracket(test).should == result
+    end
+
+    it "should bracketize correctly a phrase with a set of brackets" do
+      test = 'this <needs> bracketizing'
+      result = '<this \<needs\> bracketizing>'
+      bracket(test).should == result
+    end
+    
+  end
+
+  describe "url escaping" do
+    it "should have a wrapper on URI.escape" do
+      uri_escape("@?@!").should == URI.escape("@?@!")
+    end
+
+    it "should have a wrapper on URI.unescape" do
+      uri_unescape("@?@!").should == URI.unescape("@?@!")
+    end
+  end
+  
+end

data/vendor/mail/spec/mail/version_specific/escape_paren_1_8_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "Ruby 1.8 Extensions" do
+  
+  describe "string ascii detection" do
+    it "should say it is US-ASCII only if it is" do
+      "abc".should be_ascii_only
+    end
+    
+    it "should not say it is US-ASCII only if it isn't" do
+      "かきくけこ".should_not be_ascii_only
+    end
+    
+    it "should not say it is US-ASCII only if it is a mix" do
+      "abcかきくけこ123".should_not be_ascii_only
+    end
+    
+    it "should handle edge cases" do
+      ["\x00", "\x01", "\x40", "\x7f", "\x73"].each do |str|
+        str.should be_ascii_only
+      end
+
+      ["\x81", "\x99", "\xFF"].each do |str|
+        str.should_not be_ascii_only
+      end
+
+    end
+  end
+end
+
+

data/vendor/mail/spec/matchers/break_down_to.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module CustomMatchers
+  class BreakDownTo
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(target)
+      @target   = target
+      @failed = false
+      @expected.each_pair do |k,v|
+        unless @target.send(k) == @expected[k]
+          @failed = k
+        end
+      end
+      !@failed
+    end
+
+    def failure_message
+      "expected #{@failed} to be |#{@expected[@failed]}| " + 
+      "but was |#{@target.send(@failed)}|"
+    end
+
+    def megative_failure_message
+      "expected #{@failed} not to be |#{@expected[@failed]}| " +
+      "and was |#{@target.send(@failed)}|"
+    end
+    
+  end
+
+  # Actual matcher that is exposed.
+  def break_down_to(expected)
+    BreakDownTo.new(expected)
+  end
+end