RubyGems - fotonauts-mailfactory - Versions diffs - 1.4.0 - Mend

fotonauts-mailfactory 1.4.0

Files changed (5) hide show

data/lib/mailfactory.rb ADDED Viewed

@@ -0,0 +1,481 @@
+# = Overview:
+# A simple to use module for generating RFC compliant MIME mail
+# ---
+# = License:
+# Author:: David Powers
+# Copyright:: May, 2005
+# License:: Ruby License
+# ---
+# = Usage:
+#   require 'net/smtp'
+#   require 'rubygems'
+#   require 'mailfactory'
+#
+#
+#   mail = MailFactory.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'
+# try to bring in the mime/types module, make a dummy module if it can't be found
+begin
+  begin
+    require 'rubygems'
+  rescue LoadError
+  end
+  require 'mime/types'
+rescue LoadError
+  module MIME
+    class Types
+      def Types::type_for(filename)
+        return('')
+      end
+    end
+  end
+end
+# An easy class for creating a mail message
+class MailFactory
+  def initialize()
+    @headers = Array.new()
+    @attachments = Array.new()
+    @attachmentboundary = generate_boundary()
+    @bodyboundary = generate_boundary()
+    @html = nil
+    @text = nil
+    @charset = 'utf-8'
+    @quoted_printable_body = true
+  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
+  # 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
+  # use 'quoted-printable' encoding fot body ? (default: true)
+  # if false, then '8bit' will be used
+  def quoted_printable_body=(value)
+    @quoted_printable_body = value
+  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.type_for(filename).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.type_for(file.to_s()).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 @quoted_printable_body
+        boundary_encoding = 'quoted-printable'
+        body_text = quote_if_necessary(@text, @charset)
+        body_html = quote_if_necessary(@html, @charset)
+      else
+        boundary_encoding = '8bit'
+        body_text = @text
+        body_html = @html
+      end
+      if(@attachments.length > 0)
+        # text part
+        body << "#{buildbodyboundary("text/plain; charset=#{@charset}; format=flowed", boundary_encoding)}\r\n\r\n#{body_text}"
+        # html part if one is provided
+        if @html
+          body << "#{buildbodyboundary("text/html; charset=#{@charset}", boundary_encoding)}\r\n\r\n#{body_html}"
+        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", boundary_encoding)}\r\n\r\n#{body_text}"
+        # html part
+        body << "#{buildbodyboundary("text/html; charset=#{@charset}", boundary_encoding)}\r\n\r\n#{body_html}"
+        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/tests/test_mailfactory.rb ADDED Viewed

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+# coding:utf-8
+require 'test/unit/ui/console/testrunner'
+require File.dirname(__FILE__) + '/../lib/mailfactory.rb'
+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_MailFactory < Test::Unit::TestCase
+	def setup()
+		@mail = MailFactory.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
+end
+$options = get_options()
+Test::Unit::UI::Console::TestRunner.run(TC_MailFactory)

data/tests/testfile.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ This is a test text file

data/tests/testsheet.xls ADDED Viewed

Binary file

metadata ADDED Viewed

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: fotonauts-mailfactory
+version: !ruby/object:Gem::Version
+  version: 1.4.0
+platform: ruby
+authors:
+- David Powers
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-04-08 00:00:00 -07:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  type: :runtime
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.1
+    version:
+description: MailFactory is s simple module for producing RFC compliant mail that can include multiple attachments, multiple body parts, and arbitrary headers
+email: david@grayskies.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mailfactory.rb
+- tests/test_mailfactory.rb
+- tests/testfile.txt
+- tests/testsheet.xls
+has_rdoc: true
+homepage: http://mailfactory.rubyforge.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+requirements: []
+rubyforge_project: mailfactory
+rubygems_version: 1.2.0
+signing_key:
+specification_version: 2
+summary: MailFactory is a pure-ruby MIME mail generator
+test_files:
+- ./tests/test_mailfactory.rb