RubyGems - manveru-mailit - Versions diffs - 2009.06.08 - Mend

manveru-mailit 2009.06.08

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

data/README.md ADDED Viewed

@@ -0,0 +1,63 @@
+# Mailit
+Mailit is a simple to use library to create and send MIME compliant e-mail with
+attachments and various encodings.
+This is a fork of MailFactory and provides a mostly identical API but has been
+cleaned up, simplified, and made compliant to common Ruby idioms. I would like
+to thank David Powers for the original MailFactory, it served me well for many
+years.
+Copyright (c) 2005-2008 David Powers.
+Copyright (c) 2009      Michael Fellinger.
+This program is free software. You can re-distribute and/or modify this program
+under the same terms as Ruby itself.
+## Dependencies
+Any Ruby since 1.8.4 should work.
+Mailit can use the Rack or Mime::Types libraries to determine the mime-type of
+attachments automatically, but they are optional.
+## Usage of Mailit::Mail
+    require 'net/smtp'
+    require 'mailit'
+    mail = Mailit::Mail.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('/home/manveru/.vimrc')
+    puts mail
+## Usage of Mailit::Mailer
+Using the mail variable from above example
+    mailer = Mailit::Mailer.new
+    mailer.send(mail, :server => 'smtp.example.com', :port => 25,
+                :domain => 'example.com', :password => 'foo')
+## Todo:
+MailFactory has a method_missing that handles getting and setting of arbitrary
+headers.
+I went for the less magical #[] and #[]= methods, maybe someone can add the
+MailFactory behaviour.
+## Thanks to
+* Michael Thompson (AKA:nylon)
+  Making mailer work on windows

data/lib/mailit/mail.rb ADDED Viewed

@@ -0,0 +1,367 @@
+require 'time'
+require 'pathname'
+require 'enumerator' unless 'String'.respond_to?(:enum_for)
+module Mailit
+  # = Overview:
+  #
+  # A simple to use class to generate RFC compliant MIME email.
+  #
+  # MailIt is a fork of MailFactory and provides a mostly identical API but has
+  # been cleaned up, simplified, and made compliant to common Ruby idioms.
+  #
+  # Copyright (c) 2005-2008 David Powers.
+  # Copyright (c) 2009      Michael Fellinger.
+  #
+  # This program is free software. You can re-distribute and/or
+  # modify this program under the same terms as Ruby itself.
+  #
+  # = Usage:
+  #
+  #   require 'net/smtp'
+  #   require 'mailit'
+  #
+  #   mail = Mailit::Mail.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('/home/manveru/.vimrc')
+  #
+  #   server = 'smtp1.testmailer.com'
+  #   port = 25
+  #   domain = 'mail.from.domain'
+  #   password = 'foo'
+  #
+  #   Net::SMTP.start(server, port, domain, mail.from, password, :cram_md5) do |smtp|
+  #     smtp.send_message(mail.to_s, mail.from, mail.to)
+  #   end
+  #
+  # = Todo:
+  #
+  # * MailFactory has a method_missing that handles getting and setting of
+  #   arbitrary headers.
+  #   I went for the less magical #[] and #[]= methods.
+  #   Maybe someone can add the MailFactory behaviour.
+  class Mail
+    VERSION = '2009.03.02'
+    BOUNDARY_CHARS = [*'a'..'z'] + [*'A'..'Z'] + [*'0'..'9'] + ['.', '_']
+    BOUNDARY_PREFIX = "----=_NextPart_"
+    # body_boundary, encoding
+    BODY_BOUNDARY = "--%s\r\nContent-Type: %s\r\nContent-Transfer-Encoding: %s"
+    # attachment_boundary, mimetype, filename, filename
+    ATTACHMENT_BOUNDARY = "--%s\r\nContent-Type: %s; name=%p\r\nContent-Transfer-Encoding: base64\r\nContent-Disposition: inline; filename=%p"
+    HTML_BODY = <<BODY.strip
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=%s">
+  </head>
+  <body bgcolor="#ffffff" text="#000000">
+  %s
+  </body>
+</html>
+BODY
+    OPTIONS = {
+      :date => true,
+      :message_id => lambda{|mail|
+        time = Time.now
+        domain = mail['from'].first.to_s.split('@').last || 'localhost'
+        message_id = "<%f.%d.%d@%s>" % [time, $$, time.object_id, domain]
+      }
+    }
+    attr_accessor :charset, :text, :html, :attachment_boundary, :body_boundary
+    attr_reader :headers, :attachments
+    # Create an instance of {Mailit::Mailer}.
+    #
+    # @option options [String] :to
+    # @option options [String] :from
+    # @option options [String] :subject
+    # @option options [String] :text
+    # @option options [String] :html
+    # @author manveru
+    def initialize(options = {})
+      @headers = []
+      @attachments = []
+      @attachment_boundary = self.class.generate_boundary
+      @body_boundary = self.class.generate_boundary
+      @charset = 'utf-8'
+      @html = @text = nil
+      options.each{|key, value| __send__("#{key}=", value) }
+    end
+    def construct(options = {})
+      options = OPTIONS.merge(options)
+      time = Time.now
+      if message_id = options[:message_id]
+        self['Message-ID'] = message_id.call(self) unless self['Message-Id'].any?
+      end
+      if options[:date]
+        self['Date'] = time.rfc2822 unless self['Date'].any?
+      end
+      if multipart?
+        self['MIME-Version'] = '1.0' unless self['MIME-Version'].any?
+        unless self['Content-Type'].any?
+          if @attachments.any?
+            content_type = ('multipart/alternative; boundary=%p' % body_boundary)
+          else
+            content_type = ('multipart/mixed; boundary=%p' % attachment_boundary)
+          end
+          self['Content-Type'] = content_type
+        end
+      end
+      "#{header_string}#{body_string}"
+    end
+    alias to_s construct
+    ## Attachments
+    def add_attachment(filename, mimetype = nil, headers = nil)
+      container = {
+        :filename => Pathname.new(filename).basename,
+        :mimetype => (mimetype || mime_type_for(filename)),
+      }
+      add_attachment_common(container, file, headers)
+    end
+    alias attach add_attachment
+    def add_attachment_as(file, filename, mimetype = nil, headers = nil)
+      container = {
+        :filename => filename,
+        :mimetype => (mimetype || mime_type_for(file))
+      }
+      add_attachment_common(container, file, headers)
+    end
+    alias attach_as add_attachment_as
+    ## Shortcuts
+    def multipart?
+      html || attachments.size > 0
+    end
+    def html=(html)
+      @html = HTML_BODY % [charset, html]
+    end
+    def raw_html=(html)
+      @html = html
+    end
+    def message_id=(id)
+      self['Message-ID'] = id
+    end
+    def send(options = {})
+      Mailer.send(self, options)
+    end
+    def defer_send(options = {})
+      Mailer.defer_send(self, options)
+    end
+    ## Header handling
+    def add_header(header, value)
+      case header.to_s.downcase
+      when /^subject$/i
+        value = quoted_printable_with_instruction(value)
+      when /^(from|to|bcc|reply-to)$/i
+        value = quote_address_if_necessary(value, charset)
+      end
+      @headers << [header, value]
+    end
+    def set_header(header, value)
+      remove_header(header)
+      add_header(header, value)
+    end
+    alias []= set_header
+    def remove_header(header)
+      regex = /^#{Regexp.escape(header)}/i
+      @headers.reject!{|key, value| key =~ regex }
+    end
+    def get_header(header)
+      regex = /^#{Regexp.escape(header)}/i
+      @headers.map{|key, value| value if regex =~ key }.compact
+    end
+    alias [] get_header
+    def header_string
+      headers.join("\r\n") << "\r\n\r\n"
+    end
+    MIME_INDICATOR = "This is a multi-part message in MIME format.\r\n\r\n--%s\r\nContent-Type: multipart/alternative; boundary=%p"
+    def body_string
+      return text unless multipart?
+      body = [ MIME_INDICATOR % [attachment_boundary, body_boundary] ]
+      body << build_body_boundary("text/plain; charset=#{charset} format=flowed")
+      body << "\r\n\r\n" << quote_if_necessary(text, charset)
+      if html
+        body << build_body_boundary("text/html; charset=#{charset}")
+        body << "\r\n\r\n" << quote_if_necessary(html, charset)
+      end
+      body << "--#{body_boundary}--"
+      attachments.each do |attachment|
+        body << build_attachment_boundary(attachment)
+        body << "\r\n\r\n" << attachment[:attachment]
+        body << "\r\n--#{attachment_boundary}--"
+      end
+      body.join("\r\n\r\n")
+    end
+    private
+    def add_attachment_common(container, file, headers)
+      container[:attachment] = file_read(file)
+      container[:headers] = headers_prepare(headers)
+      self.attachments << container
+    end
+    def headers_prepare(headers)
+      case headers
+      when Array
+        container[:headers] = headers
+      else
+        container[:headers] = headers.split(/\r?\n/)
+      end
+    end
+    def quoted_printable_with_instruction(text)
+      text = encode_quoted_printable_rfc2047(text)
+      "=?#{charset}?Q?#{text}?="
+    end
+    def quote_if_necessary(text, charset, instruction = false)
+      return unless text
+      if text.respond_to?(:force_encoding)
+        text = text.dup.force_encoding(Encoding::ASCII_8BIT)
+      end
+      if instruction
+        quoted_printable_with_instruction(text)
+      else
+        encode_quoted_printable_rfc2045(text)
+      end
+    end
+    def quote_address_if_necessary(address, charset)
+      case address
+      when Array
+        address.map{|addr| quote_address_if_necessary(addr, charset) }
+      when /^(\S.*)\s+(<.*>)$/
+        phrase = $1.gsub(/^['"](.*)['"]$/, '\1')
+        address = $2
+        phrase = quote_if_necessary(phrase, charset, true)
+        "%p %s" % [phrase, address]
+      else
+        address
+      end
+    end
+    def encode_file(string)
+      [string].pack('m')
+    end
+    def file_read(file)
+      case file
+      when String, Pathname
+        File.open(file.to_s, 'rb') do |io|
+          encode_file(io.read)
+        end
+      else
+        encode_file(file.read)
+      end
+    end
+    def encode_quoted_printable_rfc2045(string)
+      [string].pack('M').gsub(/\n/, "\r\n").chomp.gsub(/=$/, '')
+    end
+    def encode_quoted_printable_rfc2047(string)
+      string.enum_for(:each_byte).map{|ord|
+        if ord < 128 and ord != 61 # 61 is ascii '='
+          ord.chr
+        else
+          '=%X' % ord
+        end
+      }.join('').chomp.
+        gsub(/=$/,'').gsub('?', '=3F').gsub('_', '=5F').gsub(/ /, '_')
+    end
+    def build_body_boundary(type, encoding = 'quoted-printable')
+      BODY_BOUNDARY % [ body_boundary, type, encoding ]
+    end
+    def build_attachment_boundary(attachment)
+      mime, file, headers = attachment.values_at(:mimetype, :filename, :headers)
+      boundary = ATTACHMENT_BOUNDARY % [attachment_boundary, mime, file, file]
+      boundary << "\r\n%s" % headers.join("\r\n") if headers
+      boundary
+    end
+    # Try to get the
+    def mime_type_for(filename, override = nil)
+      override || Mime.type_for(filename)
+    end
+    ## Header shortcuts
+    def self.header_accessors(hash)
+      hash.each{|k,v| header_accessor(k, v) }
+    end
+    def self.header_accessor(method, header)
+      public
+      eval("def %s; self[%p].first; end" % [method, header.to_s])
+      eval("def %s=(o); self[%p] = o; end" % [method, header.to_s])
+    end
+    header_accessors(:reply_to => 'Reply-To', :to => :to, :from => :from,
+                     :subject => :subject, :bcc => :bcc)
+    def self.generate_boundary(size = 25, chars = BOUNDARY_CHARS)
+      char_count = chars.size
+      postfix = Array.new(size){
+        chars[rand(char_count)]
+      }.join
+      return "#{BOUNDARY_PREFIX}#{postfix}"
+    end
+  end
+end

data/lib/mailit/mailer.rb ADDED Viewed

@@ -0,0 +1,129 @@
+module Mailit
+  # The Mailer is an abstraction layer for different SMTP clients, it provides
+  # #send and #defer_send methods
+  #
+  # At the time of writing, Net::SMTP and EventMachine::SmtpClient are
+  # supported, it should be trivial to add support for any other client.
+  #
+  # The difference between #send and #defer_send depends on the backend, but
+  # usually #send will block until the mail was sent while #defer_send does it
+  # in the background and allows you to continue execution immediately.
+  #
+  # @example Usage
+  #
+  #   mail = Mailit::Mail.new
+  #   mail.to = 'test@test.com'
+  #   mail.from = 'sender@sender.com'
+  #   mail.subject 'Here are some files for you!'
+  #   mail.text = 'This is what you see with a plaintext mail reader'
+  #   mail.attach('/home/manveru/.vimrc')
+  #
+  #   # Send and wait until sending finished
+  #   Mailit::Mailer.send(mail)
+  #
+  #   # Send in background thread and continue doing other things
+  #   Mailit::Mailer.defer_send(mail)
+  #
+  # The default Mailer backend is Mailit::Mailer::NetSmtp, you can change the
+  # default by including another module into Mailit::mailer
+  #
+  # @example Using Mailt::Mailer::EventMachine by inclusion
+  #
+  #   class Mailit::Mailer
+  #     include Mailit::Mailer::EventMachine
+  #   end
+  #
+  # Another way is to extend an instance of Mailer with the backend you want to
+  # use, which will not affect other instances.
+  #
+  # @example Using Mailit::mailer::EventMachine by extension
+  #
+  #   mailer = Mailit::Mailer.new
+  #   mailer.extend(Mailit::Mailer::EventMachine)
+  class Mailer
+    OPTIONS = {
+      :server    => 'smtp.localhost',
+      :port      => 25,
+      :domain    => 'localhost',
+      :username  => 'foo',
+      :password  => 'foo',
+      :noop      => false,
+      :auth_type => :login, # :plain, :login, :cram_md5
+      :starttls  => false,  # only useful for EventMachine::SmtpClient
+    }
+    def self.send(mail, options = {})
+      new.send(mail, options)
+    end
+    def self.defer_send(mail, options = {})
+      new.defer_send(mail, options)
+    end
+    undef :send
+    attr_reader :options
+    def initialize(options = {})
+      @options = OPTIONS.merge(options)
+      extend NetSmtp unless respond_to?(:send)
+    end
+    private
+    def settings(override, *keys)
+      options.merge(override).values_at(*keys)
+    end
+    module NetSmtp
+      def send(mail, override = {})
+        require 'net/smtp'
+        server, port, domain, username, password, auth_type =
+          settings(override, :server, :port, :domain, :username, :password, :auth_type)
+        ::Net::SMTP.start(server, port, domain, username, password, auth_type) do |smtp|
+          return if noop
+          smtp.send_message(mail.to_s, mail.from, mail.to)
+        end
+      end
+      def defer_send(mail, override = {})
+        Thread.new{ send(mail, override) }
+      end
+    end
+    # Allows you to comfortably use the EventMachine::SmtpClient.
+    # In order to use it, you have to first include this module into
+    # Mailit::Mailer or extend the Mailit::Mailer instance with it.
+    module EventMachine
+      # This assumes that EventMachine was required and we are inside the
+      # EventMachine::run block.
+      #
+      # Since EM implements some parts of the mail building we'll have to
+      # deconstruct our mail a bit.
+      # On the upside, it seems like it supports STARTTLS (without certificate
+      # options though)
+      def send(mail, options = {})
+        server, port, domain, username, password, auth_type =
+          settings(override, :server, :port, :domain, :username, :password, :auth_type)
+        mail.construct # prepare headers and body
+        em_options = { :port => port, :host => host, :domain => domain,
+          :from => mail.from, :to => mail.to, :header => mail.header_string,
+          :body => mail.body_string }
+        if auth_type
+          em_options[:auth] = {
+            :type => auth_type, :username => username, :password => password }
+        end
+        ::EventMachine::SmtpClient.send(em_options)
+      end
+      alias defer_send send
+    end
+  end
+end

data/lib/mailit/mime.rb ADDED Viewed

@@ -0,0 +1,49 @@
+module Mailit
+  module Mime
+    module_function
+    def mime_for(filename)
+      detect_handler unless defined?(@mime_handler)
+      send(@mime_handler, filename)
+    end
+    def detect_handler
+      try_require('rubygems')
+      if try_require('mime/types')
+        @mime_handler = :from_mime_types
+      elsif try_require('rack') and try_require('rack/mime')
+        @mime_handler = :from_rack
+      else
+        require 'webrick/httputils'
+        @webrick_types = WEBrick::HTTPUtils::DefaultMimeTypes.dup
+        try_extend_webrick('/etc/mime.types')
+        @mime_handler = :from_webrick
+      end
+    end
+    def from_mime_types(filename)
+      MIME::Types.type_for(filename) || 'application/octet-stream'
+    end
+    def from_rack(filename)
+      Rack::Mime.mime_type(File.extname(filename))
+    end
+    def from_webrick(filename)
+      WEBrick::HTTPUtils.mime_type(filename, @webrick_types)
+    end
+    def try_extend_webrick(file)
+      hash = WEBrick::HTTPUtils.load_mime_types(file)
+      @webrick_types.merge!(hash)
+    rescue
+    end
+    def try_require(lib)
+      require lib
+      true
+    rescue LoadError
+    end
+  end
+end

data/lib/mailit.rb ADDED Viewed

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+module Mailit
+  VERSION = '2009.03.10'
+end
+require 'mailit/mime'
+require 'mailit/mail'
+require 'mailit/mailer'

data/mailit.gemspec ADDED Viewed

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name = "mailit"
+  s.version = "2009.06.08"
+  s.summary = "RFC compliant MIME email generation and SMTP mailing."
+  s.description = "Simple to use class to generate RFC compliant MIME email."
+  s.platform = "ruby"
+  s.has_rdoc = true
+  s.author = "Michael 'manveru' Fellinger"
+  s.email = "m.fellinger@gmail.com"
+  s.homepage = "http://github.com/manveru/mailit"
+  s.require_path = "lib"
+  s.files = [
+    "README.md",
+    "lib/mailit.rb",
+    "lib/mailit/mail.rb",
+    "lib/mailit/mailer.rb",
+    "lib/mailit/mime.rb",
+    "mailit.gemspec",
+    "spec/helper.rb",
+    "spec/mailit/mail.rb",
+    "spec/mailit/mailer.rb",
+  ]
+end

data/spec/helper.rb ADDED Viewed

@@ -0,0 +1,4 @@
+require File.expand_path("#{__FILE__}/../../lib/mailit")
+require 'bacon'
+Bacon.summary_on_exit

data/spec/mailit/mail.rb ADDED Viewed

@@ -0,0 +1,108 @@
+# Encoding: UTF-8
+require 'spec/helper'
+# The specs are translated from the Test::Unit tests of MailFactory.
+#
+# TODO:
+# * test_attach_as
+# * test_email
+describe Mailit::Mail do
+  should 'set and get headers' do
+    mail = Mailit::Mail.new
+    mail.set_header('arbitrary', 'some value')
+    mail.get_header('arbitrary').should == ['some value']
+    mail.set_header('arbitrary-header', 'some _ value')
+    mail.get_header('arbitrary-header').should == ['some _ value']
+  end
+  should 'generate valid boundaries' do
+    50.times do
+      boundary = Mailit::Mail.generate_boundary
+      boundary.should =~ /^----=_NextPart_[a-zA-Z0-9_.]{25}$/
+    end
+  end
+  should 'make mail with recipient' do
+    mail = Mailit::Mail.new
+    mail.to = 'test@test.com'
+    mail.to.should == 'test@test.com'
+    mail.to = 'test@test2.com'
+    mail.to.should == 'test@test2.com'
+    mail.headers.size.should == 1 # make sure the previous was deleted
+  end
+  should 'make mail with sender' do
+    mail = Mailit::Mail.new
+    mail.from = 'test@test.com'
+    mail.from.should == 'test@test.com'
+    mail.from = 'test@test2.com'
+    mail.from.should == 'test@test2.com'
+    mail.headers.size.should == 1 # make sure the previous was deleted
+  end
+  should 'set correct subject' do
+    mail = Mailit::Mail.new
+    mail.subject = 'Test Subject'
+    mail.subject.should == '=?utf-8?Q?Test_Subject?='
+    mail.subject = 'A Different Subject'
+    mail.subject.should == '=?utf-8?Q?A_Different_Subject?='
+    mail.headers.size.should == 1 # make sure the previous was deleted
+  end
+  should 'use quoted printable with instruction' do
+    mail = Mailit::Mail.new
+    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."
+    mail.subject.should == "=?utf-8?Q?My_email_subject_has_a_=3F_in_it_and_also_an_=3D_and_a_=5F_too..._Also_some_non-quoted_junk_()!@\#\{\$\%\}?="
+  end
+  should 'use subject quoting for scandinavian string' do
+    mail = Mailit::Mail.new
+    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."
+    mail.subject.should == "=?utf-8?Q?=C3=A4=C3=A4=C3=A4=C3=B6=C3=B6=C3=B6?="
+  end
+  should 'use subject quoting for utf-8 string' do
+    mail = Mailit::Mail.new
+    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."
+    mail.subject.should == "=?utf-8?Q?My_email_subject_has_a_=C3=83_which_is_utf8.?="
+  end
+  should 'encode html as quoted printable' do
+    mail = Mailit::Mail.new
+    mail.to = "test@test.com"
+    mail.from = "test@othertest.com"
+    mail.subject = "some html"
+    mail.html = "<a href=\"http://google.com\">click here</a>"
+    mail.to_s.should.include('<a href=3D"http://google.com">click here</a>')
+  end
+end

data/spec/mailit/mailer.rb ADDED Viewed

@@ -0,0 +1,48 @@
+require 'spec/helper'
+class MockSMTP
+  INSTANCES = []
+  def self.start(*args, &block)
+    INSTANCES << new(*args, &block)
+  end
+  attr_reader :start_args, :result, :send_message_args
+  def initialize(*args, &block)
+    @start_args = args
+    yield(self)
+  end
+  def send_message(*args)
+    @send_message_args = args
+  end
+end
+Mailit::Mail::OPTIONS[:message_id] = lambda{|mail| '1234' }
+describe Mailit::Mailer do
+  it 'sends a mail' do
+    mail = Mailit::Mail.new(
+      :to => 'test@example.com',
+      :from => 'sender@example.com',
+      :subject => 'Here are some files for you!',
+      :text => 'Some text about that')
+    mailer = Mailit::Mailer.new
+    mailer.send(mail, :server => 'smtp.example.com', :port => 25,
+                :domain => 'example.com', :password => 'foo',
+                :mailer => MockSMTP)
+    mock = MockSMTP::INSTANCES.last
+    mock.start_args.should == [
+      'smtp.example.com', 25,
+      'example.com',
+      'sender@example.com',
+      'foo',
+      :cram_md5
+    ]
+    mock.send_message_args.should == [mail.to_s, mail.from, mail.to]
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: manveru-mailit
+version: !ruby/object:Gem::Version
+  version: 2009.06.08
+platform: ruby
+authors:
+- Michael 'manveru' Fellinger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-05-16 00:00:00 -07:00
+default_executable:
+dependencies: []
+description: Simple to use class to generate RFC compliant MIME email.
+email: m.fellinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mailit.rb
+- lib/mailit/mail.rb
+- lib/mailit/mailer.rb
+- lib/mailit/mime.rb
+- mailit.gemspec
+- spec/helper.rb
+- spec/mailit/mail.rb
+- spec/mailit/mailer.rb
+has_rdoc: true
+homepage: http://github.com/manveru/mailit
+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:
+rubygems_version: 1.2.0
+signing_key:
+specification_version: 2
+summary: RFC compliant MIME email generation and SMTP mailing.
+test_files: []