kuvert 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8954c2b806b2e4ecdea6b2b3e897e618424c756
+  data.tar.gz: e06e1405adf0777d7ea12e6be06ced1fbacd6a38
+SHA512:
+  metadata.gz: da810f127283d91127053e78c6a2edff3d7b273c8613ae431519ef350241a9303112cdbc0ad4418a918fa9be5b06949cd267e0ea2a54b45763c9148cccf3a298
+  data.tar.gz: 6f8f63c165c89c8bd959cff74be1154a129b27d7e87f88146f575d4df4ea556fca3173d081036d8ea7e593a8603cbeee928e1406381b4c529d063577042bc9fc

data/.gems

@@ -0,0 +1 @@
+mime-types -v 2.4.3

data/Makefile

@@ -0,0 +1,4 @@
+test: .PHONY
+	ruby test/kuvert_test.rb
+
+.PHONY:

data/README.markdown

@@ -0,0 +1,28 @@
+kuvert
+======
+
+Continuing the legacy of [MailFactory][1].
+
+## Usage
+
+```ruby
+mail = Kuvert.new
+mail.to = 'dst@mailinator.com'
+mail.from = 'src@mailinator.com'
+mail.subject = 'hello'
+mail.text = 'wonderful day to you!'
+mail.attach('/path/to/your.pdf')
+mail.to_s
+```
+
+## Credit
+
+All of the credit goes to David Powers for his original
+work on [MailFactory][1].
+
+## License
+
+[Ruby License][2]
+
+[1]: http://rubygems.org/gems/mailfactory
+[2]: https://www.ruby-lang.org/en/about/license.txt

data/kuvert.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = "kuvert"
+  s.version = "0.0.1"
+  s.summary = %{Continuing the MailFactory legacy}
+  s.description = %{Keep MailFactory updated with the times}
+  s.authors = ["David Powers", "Cyril David"]
+  s.email = ["cyx@cyx.is"]
+  s.homepage = "http://github.com/cyx/kuvert"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_dependency "mime-types", "~> 2.4"
+end

data/lib/kuvert.rb

@@ -0,0 +1,439 @@
+# = Overview:
+# A simple to use module for generating RFC compliant MIME mail
+# ---
+# = License:
+# Author:: David Powers
+# Contributors: Cyril David
+# Copyright:: May, 2005
+# License:: Ruby License
+# ---
+# = Usage:
+#   require 'net/smtp'
+#   require 'rubygems'
+#   require 'mailfactory'
+#
+#
+#   mail = Kuvert.new()
+#   mail.to = "test@test.com"
+#   mail.from = "sender@sender.com"
+#   mail.subject = "Here are some files for you!"
+#   mail.text = "This is what people with plain text mail readers will see"
+#   mail.html = "A little something <b>special</b> for people with HTML readers"
+#   mail.attach("/etc/fstab")
+#   mail.attach("/some/other/file")
+#
+#   Net::SMTP.start('smtp1.testmailer.com', 25, 'mail.from.domain', fromaddress, password, :cram_md5) { |smtp|
+#     mail.to = toaddress
+#     smtp.send_message(mail.to_s(), fromaddress, toaddress)
+#   }
+
+require 'pathname'
+require 'mime/types'
+
+# An easy class for creating a mail message
+class Kuvert
+
+  VERSION = '1.4.0'
+
+  attr :bcc
+
+  def initialize()
+    @headers = Array.new()
+    @attachments = Array.new()
+    @attachmentboundary = generate_boundary()
+    @bodyboundary = generate_boundary()
+    @html = nil
+    @text = nil
+    @charset = 'utf-8'
+    @bcc = []
+  end
+
+  # adds a header to the bottom of the headers
+  def add_header(header, value)
+    value = quoted_printable_with_instruction(value, @charset) if header == 'subject'
+    value = quote_address_if_necessary(value, @charset) if %w[from to cc bcc reply-to].include?(header.downcase)
+    @headers << "#{header}: #{value}"
+  end
+
+  # removes the named header - case insensitive
+  def remove_header(header)
+    @headers.each_index() { |i|
+      if(@headers[i] =~ /^#{Regexp.escape(header)}:/i)
+        @headers.delete_at(i)
+      end
+    }
+  end
+
+  # sets a header (removing any other versions of that header)
+  def set_header(header, value)
+    remove_header(header)
+    add_header(header, value)
+  end
+
+  def replyto=(newreplyto)
+    remove_header("Reply-To")
+    add_header("Reply-To", newreplyto)
+  end
+
+  def replyto()
+    return(get_header("Reply-To")[0])
+  end
+
+  def bcc=(bcc)
+    @bcc.push(bcc)
+  end
+
+  def recipients
+    [].tap do |ret|
+      ret.push(*to)
+      ret.push(*cc)
+      ret.push(*bcc)
+    end
+  end
+
+  # sets the plain text body of the message
+  def text=(newtext)
+    @text = newtext
+  end
+
+  # sets the HTML body of the message. Only the body of the
+  # html should be provided
+  def html=(newhtml)
+    @html = "<html>\n<head>\n<meta content=\"text/html;charset=#{@charset}\" http-equiv=\"Content-Type\">\n</head>\n<body bgcolor=\"#ffffff\" text=\"#000000\">\n#{newhtml}\n</body>\n</html>"
+  end
+
+  # sets the HTML body of the message.  The entire HTML section should be provided
+  def rawhtml=(newhtml)
+    @html = newhtml
+  end
+
+  # implement method missing to provide helper methods for setting and getting headers.
+  # Headers with '-' characters may be set/gotten as 'x_mailer' or 'XMailer' (splitting
+  # will occur between capital letters or on '_' chracters)
+  def method_missing(methId, *args)
+    name = methId.id2name()
+
+    # mangle the name if we have to
+    if(name =~ /_/)
+      name = name.gsub(/_/, '-')
+    elsif(name =~ /[A-Z]/)
+      name = name.gsub(/([a-zA-Z])([A-Z])/, '\1-\2')
+    end
+
+    # determine if it sets or gets, and do the right thing
+    if(name =~ /=$/)
+      if(args.length != 1)
+        super(methId, args)
+      end
+      set_header(name[/^(.*)=$/, 1], args[0])
+    else
+      if(args.length != 0)
+        super(methId, args)
+      end
+      headers = get_header(name)
+      return(get_header(name))
+    end
+  end
+
+  # returns the value (or values) of the named header in an array
+  def get_header(header)
+    headers = Array.new()
+    headerregex = /^#{Regexp.escape(header)}:/i
+    @headers.each() { |h|
+      if(headerregex.match(h))
+        headers << h[/^[^:]+:(.*)/i, 1].strip()
+      end
+    }
+
+    return(headers)
+  end
+
+  # returns true if the email is multipart
+  def multipart?()
+    if(@attachments.length > 0 or @html != nil)
+      return(true)
+    else
+      return(false)
+    end
+  end
+
+  # builds an email and returns it as a string.  Takes the following options:
+  # <tt>:messageid</tt>:: Adds a message id to the message based on the from header (defaults to false)
+  # <tt>:date</tt>:: Adds a date to the message if one is not present (defaults to true)
+  def construct(options = Hash.new)
+    if(options[:date] == nil)
+      options[:date] = true
+    end
+
+    if(options[:messageid])
+      # add a unique message-id
+      remove_header("Message-ID")
+      sendingdomain = get_header('from')[0].to_s()[/@([-a-zA-Z0-9._]+)/,1].to_s()
+      add_header("Message-ID", "<#{Time.now.to_f()}.#{Process.euid()}.#{String.new.object_id()}@#{sendingdomain}>")
+    end
+
+    if(options[:date])
+      if(get_header("Date").length == 0)
+        add_header("Date", Time.now.strftime("%a, %d %b %Y %H:%M:%S %z"))
+      end
+    end
+
+    # Add a mime header if we don't already have one and we have multiple parts
+    if(multipart?())
+      if(get_header("MIME-Version").length == 0)
+        add_header("MIME-Version", "1.0")
+      end
+
+      if(get_header("Content-Type").length == 0)
+        if(@attachments.length == 0)
+          add_header("Content-Type", "multipart/alternative;boundary=\"#{@bodyboundary}\"")
+        else
+          add_header("Content-Type", "multipart/mixed; boundary=\"#{@attachmentboundary}\"")
+        end
+      end
+    end
+
+    return("#{headers_to_s()}#{body_to_s()}")
+  end
+
+  # returns a formatted email - equivalent to construct(:messageid => true)
+  def to_s()
+    return(construct(:messageid => true))
+  end
+
+  # generates a unique boundary string
+  def generate_boundary()
+    randomstring = Array.new()
+    1.upto(25) {
+      whichglyph = rand(100)
+      if(whichglyph < 40)
+        randomstring << (rand(25) + 65).chr()
+      elsif(whichglyph < 70)
+        randomstring << (rand(25) + 97).chr()
+      elsif(whichglyph < 90)
+        randomstring << (rand(10) + 48).chr()
+      elsif(whichglyph < 95)
+        randomstring << '.'
+      else
+        randomstring << '_'
+      end
+    }
+    return("----=_NextPart_#{randomstring.join()}")
+  end
+
+  # adds an attachment to the mail.  Type may be given as a mime type.  If it
+  # is left off and the MIME::Types module is available it will be determined automagically.
+  # If the optional attachemntheaders is given, then they will be added to the attachment
+  # boundary in the email, which can be used to produce Content-ID markers.  attachmentheaders
+  # can be given as an Array or a String.
+  def add_attachment(filename, type=nil, attachmentheaders = nil)
+    attachment = Hash.new()
+    attachment['filename'] = Pathname.new(filename).basename
+    if(type == nil)
+      attachment['mimetype'] = MIME::Types.of(filename).first.to_s
+    else
+      attachment['mimetype'] = type
+    end
+
+    # Open in rb mode to handle Windows, which mangles binary files opened in a text mode
+    File.open(filename, "rb") { |fp|
+      attachment['attachment'] = file_encode(fp.read())
+    }
+
+    if(attachmentheaders != nil)
+      if(!attachmentheaders.kind_of?(Array))
+        attachmentheaders = attachmentheaders.split(/\r?\n/)
+      end
+      attachment['headers'] = attachmentheaders
+    end
+
+    @attachments << attachment
+  end
+
+  # adds an attachment to the mail as emailfilename.  Type may be given as a mime type.  If it
+  # is left off and the MIME::Types module is available it will be determined automagically.
+  # file may be given as an IO stream (which will be read until the end) or as a filename.
+  # If the optional attachemntheaders is given, then they will be added to the attachment
+  # boundary in the email, which can be used to produce Content-ID markers.  attachmentheaders
+  # can be given as an Array of a String.
+  def add_attachment_as(file, emailfilename, type=nil, attachmentheaders = nil)
+    attachment = Hash.new()
+    attachment['filename'] = emailfilename
+
+    if(type != nil)
+      attachment['mimetype'] = type.to_s()
+    elsif(file.kind_of?(String) or file.kind_of?(Pathname))
+      attachment['mimetype'] = MIME::Types.of(file.to_s()).first.to_s
+    else
+      attachment['mimetype'] = ''
+    end
+
+    if(file.kind_of?(String) or file.kind_of?(Pathname))
+      # Open in rb mode to handle Windows, which mangles binary files opened in a text mode
+      File.open(file.to_s(), "rb") { |fp|
+        attachment['attachment'] = file_encode(fp.read())
+      }
+    elsif(file.respond_to?(:read))
+      attachment['attachment'] = file_encode(file.read())
+    else
+      raise(Exception, "file is not a supported type (must be a String, Pathnamem, or support read method)")
+    end
+
+    if(attachmentheaders != nil)
+      if(!attachmentheaders.kind_of?(Array))
+        attachmentheaders = attachmentheaders.split(/\r?\n/)
+      end
+      attachment['headers'] = attachmentheaders
+    end
+
+    @attachments << attachment
+  end
+
+  alias attach add_attachment
+  alias attach_as add_attachment_as
+
+protected
+
+  # returns the @headers as a properly formatted string
+  def headers_to_s()
+    return("#{@headers.join("\r\n")}\r\n\r\n")
+  end
+
+  # returns the body as a properly formatted string
+  def body_to_s()
+    body = Array.new()
+
+    # simple message with one part
+    if(!multipart?())
+      return(@text)
+    else
+      body << "This is a multi-part message in MIME format.\r\n\r\n--#{@attachmentboundary}\r\nContent-Type: multipart/alternative; boundary=\"#{@bodyboundary}\""
+
+      if(@attachments.length > 0)
+        # text part
+        body << "#{buildbodyboundary("text/plain; charset=#{@charset}; format=flowed", 'quoted-printable')}\r\n\r\n#{quote_if_necessary(@text, @charset)}"
+
+        # html part if one is provided
+        if @html
+          body << "#{buildbodyboundary("text/html; charset=#{@charset}", 'quoted-printable')}\r\n\r\n#{quote_if_necessary(@html, @charset)}"
+        end
+
+        body << "--#{@bodyboundary}--"
+
+        # and, the attachments
+        if(@attachments.length > 0)
+          @attachments.each() { |attachment|
+            body << "#{buildattachmentboundary(attachment)}\r\n\r\n#{attachment['attachment']}"
+          }
+          body << "\r\n--#{@attachmentboundary}--"
+        end
+      else
+        # text part
+        body << "#{buildbodyboundary("text/plain; charset=#{@charset}; format=flowed", 'quoted-printable')}\r\n\r\n#{quote_if_necessary(@text, @charset)}"
+
+        # html part
+        body << "#{buildbodyboundary("text/html; charset=#{@charset}", 'quoted-printable')}\r\n\r\n#{quote_if_necessary(@html, @charset)}"
+
+        body << "--#{@bodyboundary}--"
+      end
+
+      return(body.join("\r\n\r\n"))
+    end
+  end
+
+  # builds a boundary string for including attachments in the body, expects an attachment hash as built by
+  # add_attachment and add_attachment_as
+  def buildattachmentboundary(attachment)
+    disposition = "Content-Disposition: inline; filename=\"#{attachment['filename']}\""
+    boundary = "--#{@attachmentboundary}\r\nContent-Type: #{attachment['mimetype']}; name=\"#{attachment['filename']}\"\r\nContent-Transfer-Encoding: base64\r\n#{disposition}"
+    if(attachment['headers'])
+      boundary = boundary + "\r\n#{attachment['headers'].join("\r\n")}"
+    end
+
+    return(boundary)
+  end
+
+  # builds a boundary string for inclusion in the body of a message
+  def buildbodyboundary(type, encoding)
+    return("--#{@bodyboundary}\r\nContent-Type: #{type}\r\nContent-Transfer-Encoding: #{encoding}")
+  end
+
+  # returns a base64 encoded version of the contents of str
+  def file_encode(str)
+    collection = Array.new()
+    enc = [str].pack('m')
+    #  while(enc.length > 60)
+    #    collection << enc.slice!(0..59)
+    #  end
+    #  collection << enc
+    #  return(collection.join("\n"))
+    return(enc)
+  end
+
+  # Convert the given text into quoted printable format, with an instruction
+  # that the text be eventually interpreted in the given charset.
+
+  def quoted_printable_with_instruction(text, charset)
+    text = quoted_printable_encode_header(text)
+    "=?#{charset}?Q?#{text}?="
+  end
+
+  # rfc2045 compatible. use rfc2047 for headers (such as the Subject line) instead
+  def quoted_printable_encode(text)
+    [text].pack('M').gsub(/\n/, "\r\n").chomp.gsub(/=$/, '')
+  end
+
+  # Convert the given character to quoted printable format
+  # see http://tools.ietf.org/html/rfc2047
+
+  require 'enumerator' unless ''.respond_to? :enum_for
+
+  def quoted_printable_encode_header(text)
+    text.enum_for(:each_byte).map do |ord|
+      if ord < 128 and ord != 61 # 61 is ascii '='
+        ord.chr
+      else
+        '=%X' % ord
+      end
+    end.join('').
+        chomp.
+        gsub(/=$/,'').
+        gsub('?', '=3F').
+        gsub('_', '=5F').
+        gsub(/ /, '_')
+  end
+
+  # A quick-and-dirty regexp for determining whether a string contains any
+  # characters that need escaping.
+  #--
+  # Jun18-08: deprecated, since all multipart blocks are marked quoted-printable, quoting is required
+
+  # if !defined?(CHARS_NEEDING_QUOTING)
+  #   CHARS_NEEDING_QUOTING = /[\000-\011\013\014\016-\037\177-\377]/
+  # end
+
+  # Quote the given text if it contains any "illegal" characters
+  def quote_if_necessary(text, charset, instruction = false)
+    return unless text
+    text = text.dup.force_encoding(Encoding::ASCII_8BIT) if text.respond_to?(:force_encoding)
+    #(text =~ CHARS_NEEDING_QUOTING) ? (instruction ? quoted_printable_with_instruction(text, charset) : quoted_printable_encode(text)) : text
+    instruction ? quoted_printable_with_instruction(text, charset) : quoted_printable_encode(text)
+  end
+
+  # Quote the given address if it needs to be. The address may be a
+  # regular email address, or it can be a phrase followed by an address in
+  # brackets. The phrase is the only part that will be quoted, and only if
+  # it needs to be. This allows extended characters to be used in the
+  # "to", "from", "cc", and "bcc" headers.
+  def quote_address_if_necessary(address, charset)
+    if Array === address
+      address.map { |a| quote_address_if_necessary(a, charset) }
+    elsif address =~ /^(\S.*)\s+(<.*>)$/
+      address = $2
+      phrase = quote_if_necessary($1.gsub(/^['"](.*)['"]$/, '\1'), charset, true)
+      "\"#{phrase}\" #{address}"
+    else
+      address
+    end
+  end
+end

data/test/kuvert_test.rb

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+# coding:utf-8
+
+require 'test/unit/ui/console/testrunner'
+require_relative '../lib/kuvert'
+
+def get_options()
+	options = Hash.new()
+
+	opts = OptionParser.new() { |opts|
+		opts.on_tail("-h", "--help", "Print this message") {
+			print(opts)
+			exit()
+		}
+
+		opts.on("-s", "--smtpserver SERVER", "SMTP server to use for remote tests") { |server|
+			options['smtpserver'] = server
+		}
+
+		opts.on("-f", "--from ADDRESS", "address to send the mail from") { |address|
+			options['from'] = address
+		}
+
+		opts.on("-t", "--to ADDRESS", "address to send the mail to") { |address|
+			options['to'] = address
+		}
+
+		opts.on("-u", "--username USERNAME", "username for smtp auth (required)") { |username|
+			options['username'] = username
+		}
+
+		opts.on("-p", "--password PASSWORD", "password for smtp auth (required)") { |password|
+			options['password'] = password
+		}
+
+	}
+
+	opts.parse(ARGV)
+
+	return(options)
+end
+
+
+
+class TC_Kuvert < Test::Unit::TestCase
+
+	def setup()
+		@mail = Kuvert.new
+	end
+
+
+	def test_set_to
+		assert_nothing_raised("exception raised while setting to=") {
+			@mail.to = "test@test.com"
+		}
+
+		assert_equal(@mail.to, ["test@test.com"], "to does not equal what it was set to")
+
+		assert_nothing_raised("exception raised while setting to=") {
+			@mail.to = "test@test2.com"
+		}
+
+		# count to headers in the final message to make sure we have only one
+		count = 0
+		@mail.to_s().each_line() { |line|
+			if(line =~ /^To:/i)
+				count = count + 1
+			end
+		}
+		assert_equal(1, count, "Count of To: headers expected to be 1, but was #{count}")
+	end
+
+
+	def test_set_from
+		assert_nothing_raised("exception raised while setting from=") {
+			@mail.from = "test@test.com"
+		}
+
+		assert_equal(@mail.from, ["test@test.com"], "from does not equal what it was set to")
+
+		assert_nothing_raised("exception raised while setting from=") {
+			@mail.from = "test@test2.com"
+		}
+
+		# count to headers in the final message to make sure we have only one
+		count = 0
+		@mail.to_s().each_line() { |line|
+			if(line =~ /^From:/i)
+				count = count + 1
+			end
+		}
+		assert_equal(1, count, "Count of From: headers expected to be 1, but was #{count}")
+	end
+
+
+	def test_set_subject
+		assert_nothing_raised("exception raised while setting subject=") {
+			@mail.subject = "Test Subject"
+		}
+
+		assert_equal(["=?utf-8?Q?Test_Subject?="], @mail.subject, "subject does not equal what it was set to")
+
+		assert_nothing_raised("exception raised while setting subject=") {
+			@mail.subject = "A Different Subject"
+		}
+
+		# count to headers in the final message to make sure we have only one
+		count = 0
+		@mail.to_s().each_line() { |line|
+			if(line =~ /^Subject:/i)
+				count = count + 1
+			end
+		}
+		assert_equal(1, count, "Count of Subject: headers expected to be 1, but was #{count}")
+	end
+
+
+	def test_set_header
+		assert_nothing_raised("exception raised while setting arbitrary header") {
+			@mail.set_header("arbitrary", "some value")
+		}
+
+		assert_equal("some value", @mail.get_header("arbitrary")[0], "arbitrary header does not equal \"some value\"")
+
+		assert_nothing_raised("exception raised while setting arbitrary header with _") {
+			@mail.arbitrary_header = "some _ value"
+		}
+
+		assert_equal(["some _ value"], @mail.get_header("arbitrary-header"), "arbitrary header does not equal \"some _ value\"")
+		assert_equal(["some _ value"], @mail.arbitrary_header, "arbitrary header does not equal \"some _ value\"")
+
+
+		assert_nothing_raised("exception raised while setting arbitraryHeader") {
+			@mail.arbitraryHeader = "someValue"
+		}
+
+		assert_equal(["someValue"], @mail.get_header("arbitrary-header"), "arbitrary header does not equal \"someValue\"")
+		assert_equal(["someValue"], @mail.arbitraryHeader, "arbitrary header does not equal \"someValue\"")
+	end
+
+
+	def test_boundary_generator
+		1.upto(50) {
+			assert_match(/^----=_NextPart_[a-zA-Z0-9\._]{25}$/, @mail.generate_boundary(), "illegal message boundary generated")
+		}
+	end
+
+
+	def test_email
+		@mail.to="test@test.com"
+		@mail.from="test@othertest.com"
+		@mail.subject="This is a test"
+		@mail.text = "This is a test message with\na few\n\nlines."
+
+		@mail.attach(File.dirname(__FILE__) + '/testfile.txt')
+		@mail.attach(File.dirname(__FILE__) + '/testsheet.xls')
+
+		if($options['smtpserver'] != nil and $options['to'] != nil and $options['from'] != nil)
+			assert_nothing_raised() {
+				require('net/smtp')
+				Net::SMTP.start($options['smtpserver'], 25, 'mail.from.domain', $options['username'], $options['password'], :cram_md5) { |smtp|
+	              smtp.send_message(@mail.to_s(), $options['from'], $options['to'])
+	      	}
+			}
+		end
+	end
+
+
+	def test_attach_as
+		@mail.to="test@test.com"
+		@mail.from="test@othertest.com"
+		@mail.subject="This is a test"
+		@mail.text = "This is a test message with\na few\n\nlines."
+
+		@mail.add_attachment_as(File.dirname(__FILE__) + '/testfile.txt', 'newname.txt')
+		@mail.add_attachment_as(File.open(File.dirname(__FILE__) + '/testsheet.xls', 'rb'), 'newname.xls', 'application/vnd.ms-excel')
+
+		if($options['smtpserver'] != nil and $options['to'] != nil and $options['from'] != nil)
+			assert_nothing_raised() {
+				require('net/smtp')
+				Net::SMTP.start($options['smtpserver'], 25, 'mail.from.domain', $options['username'], $options['password'], :cram_md5) { |smtp|
+		           smtp.send_message(@mail.to_s(), $options['from'], $options['to'])
+		   	}
+			}
+		end
+	end
+
+	def test_quoted_printable_with_instruction
+	  @mail.to="test@test.com"
+		@mail.from="test@othertest.com"
+		@mail.subject="My email subject has a ? in it and also an = and a _ too... Also some non-quoted junk ()!@\#\{\$\%\}"
+		@mail.text = "This is a test message with\na few\n\nlines."
+    assert_equal(["=?utf-8?Q?My_email_subject_has_a_=3F_in_it_and_also_an_=3D_and_a_=5F_too..._Also_some_non-quoted_junk_()!@\#\{\$\%\}?="], @mail.subject)
+  end
+
+  def test_scandinavian_subject_quoting
+    @mail.to="test@test.com"
+    @mail.from="test@othertest.com"
+    # Three a with dots and three o with dots.
+    @mail.subject="\303\244\303\244\303\244\303\266\303\266\303\266"
+    @mail.text = "This is a test message with\na few\n\nlines."
+    assert_equal(["=?utf-8?Q?=C3=A4=C3=A4=C3=A4=C3=B6=C3=B6=C3=B6?="], @mail.subject)
+  end
+
+  def test_utf8_quoted_printable_with_instruction
+    @mail.to="test@test.com"
+    @mail.from="test@othertest.com"
+    @mail.subject="My email subject has a à which is utf8."
+    @mail.text = "This is a test message with\na few\n\nlines."
+    assert_equal(["=?utf-8?Q?My_email_subject_has_a_=C3=83_which_is_utf8.?="], @mail.subject)
+  end
+
+  def test_quoted_printable_html
+    @mail.to="test@test.com"
+    @mail.from="test@othertest.com"
+    @mail.subject="some html"
+    @mail.html="<a href=\"http://google.com\">click here</a>"
+    assert_match('<a href=3D"http://google.com">click here</a>', @mail.to_s)
+  end
+
+  def test_bcc_not_in_headers
+    @mail.bcc = 'bcc@test.com'
+    assert_no_match(/bcc@test\.com/, @mail.to_s)
+  end
+
+  def test_recipients
+    @mail.to="test@test.com"
+    @mail.cc="cc@test.com"
+    @mail.bcc="bcc@test.com"
+    assert_equal(['test@test.com', 'cc@test.com', 'bcc@test.com'], @mail.recipients)
+  end
+end
+
+$options = get_options()
+Test::Unit::UI::Console::TestRunner.run(TC_Kuvert)

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: kuvert
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Powers
+- Cyril David
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: Keep MailFactory updated with the times
+email:
+- cyx@cyx.is
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gems"
+- Makefile
+- README.markdown
+- kuvert.gemspec
+- lib/kuvert.rb
+- test/kuvert_test.rb
+- test/testfile.txt
+- test/testsheet.xls
+homepage: http://github.com/cyx/kuvert
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Continuing the MailFactory legacy
+test_files: []