tape 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008-2009 Ben Mabey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+Tape
+====
+
+A rewrite of email\_spec that borrows a lot but gets rid of bloat. Currently ships with the following adapters:
+
+* ActionMailer (:test, :active\_record, :maildir)
+* Pony
+
+Implementing your own adapter is easy. See below.
+
+It does *NOT* handle Delayed::Job implicitly. Trigger your workers before checking for mail.
+
+Compatibility
+-------------
+
+For convenience, `email_spec` helpers and matchers are available in the `Tape::EmailSpec` module. Use them if you want to migrate an existing project from `email_spec` to `tape`.
+
+Example
+-------
+
+    require 'tape'
+
+    # This will set up your adapter
+    Tape.configure 'action_mailer/test'
+
+    # Get all mails
+    Tape.adapter.all
+
+    # Get last mail
+    Tape.adapter.last
+
+    # Clear mails
+    Tape.adapter.reset
+
+
+Implementing an adapter
+-----------------------
+
+Adapters inherit from Tape::Adapters::Base and implement only three self-explanatory methods:
+
+* all
+* last
+* reset

data/lib/tape.rb

@@ -0,0 +1,33 @@
+module Tape
+
+  module EmailSpec
+    autoload :Helpers,          'tape/email_spec/helpers'
+    autoload :Matchers,         'tape/email_spec/matchers'
+    autoload :AddressConverter, 'tape/email_spec/address_converter'
+  end
+
+  module Adapters
+    autoload :Base, 'tape/adapters/base'
+    autoload :Pony, 'tape/adapters/pony'
+
+    module ActionMailer
+      autoload :Cache,   'tape/adapters/action_mailer/cache'
+      autoload :Maildir, 'tape/adapters/action_mailer/maildir'
+      autoload :Test,    'tape/adapters/action_mailer/test'
+    end
+  end
+
+  def self.configure(adapter, options = {})
+    klass = "Tape::Adapters::#{adapter.to_s.camelize}".constantize
+    @adapter = klass.new(options)
+  end
+
+  def self.adapter
+    @adapter || begin
+      raise "You need to call Tape.configure to set up your adapter"
+    end
+  end
+
+end
+
+require 'tape/mail_ext'

data/lib/tape/adapters.asfdsf

@@ -0,0 +1,19 @@
+module Tape
+
+  module Adapters
+
+    def all_emails
+      Tape.adapter.all
+    end
+
+    def reset_mailer
+      Tape.adapter.reset
+    end
+
+    def mailbox_for(address)
+      Tape.adapter.by_recipient address
+    end
+
+  end
+
+end

data/lib/tape/adapters/action_mailer/active_record.rb

@@ -0,0 +1,45 @@
+module Tape
+  
+  module Adapters
+
+    module ActionMailer
+
+      # For ActionMailer with delivery_method = :activerecord
+      class ActiveRecord
+
+        def initialize(options)
+          super options
+
+          # Default to Email if no model is configured.
+          unless self.options[:model]
+            self.options[:model] if const_defined?(Email)
+          end
+        end
+
+        def all
+          model.all.map { |email| parse email.mail }
+        end
+
+        def last
+          if email = model.last
+            parse mail
+          end
+        end
+
+        def reset
+          model.delete_all
+        end
+
+        protected
+
+        def model
+          options[:model]
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/tape/adapters/action_mailer/cache.rb

@@ -0,0 +1,28 @@
+module Tape
+  
+  module Adapteres
+
+    module ActionMailer
+
+      # For ActionMailer with delivery_method = :cache
+      class Cache < Base
+
+        def all
+          ActionMailer::Base.cached_deliveries
+        end
+
+        def last
+          ActionMailer::Base.cached_deliveries.last
+        end
+
+        def reset
+          ActionMailer::Base.clear_cache
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/tape/adapters/action_mailer/maildir.rb

@@ -0,0 +1,38 @@
+require 'maildir'
+
+module Tape
+
+  module Adapters
+
+    module ActionMailer
+
+      # For ActionMailer with delivery_method = :maildir.
+      class Maildir < Base
+
+        def initialize(options = {})
+          super options
+          @maildir = ::Maildir.new(options[:path])
+          @maildir.serializer = ::Maildir::Serializer::Mail.new
+        end
+
+        def all
+          @maildir.list(:new).collect(&:data)
+        end
+
+        def last
+          # FIXME: Sort by date
+          all.last
+        end
+
+        def reset
+          @maildir.list(:new).each do |message|
+            message.destroy
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/tape/adapters/action_mailer/test.rb

@@ -0,0 +1,28 @@
+module Tape
+
+  module Adapters
+
+    module ActionMailer
+
+      # For ActionMailer with delivery_method = :test
+      class Test < Base
+
+        def all
+          ActionMailer::Base.deliveries
+        end
+
+        def last
+          ActionMailer::Base.deliveries.last
+        end
+
+        def reset
+          ActionMailer::Base.deliveries.clear
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/tape/adapters/base.rb

@@ -0,0 +1,39 @@
+module Tape
+
+  module Adapters
+
+    class Base
+
+      attr_accessor :options
+
+      def initialize(options)
+        self.options = options
+      end
+
+      def all
+        raise "Not implemented"
+      end
+     
+      # Returns the last sent mail or nil if there is none.
+      def last
+        raise "Not implemented"
+      end
+
+      def reset
+        raise "Not implemented"
+      end
+
+      def by_recipient(address)
+        all.select do |mail|
+          mail.destinations.include?(address)
+        end
+      end
+
+      def parse(mail)
+        Mail.read mail
+      end
+    end
+
+  end
+
+end

data/lib/tape/adapters/pony.rb

@@ -0,0 +1,36 @@
+module Tape
+
+  module Adapters
+    # Using Pony
+    class Pony < Base
+
+      def all
+        ::Pony.deliveries
+      end
+
+      def last
+        ::Pony.deliveries.last
+      end
+
+      def reset
+        ::Pony.deliveries.clear
+      end
+
+    end
+
+  end
+
+end
+
+# Monkey-patch pony to not really send mails but store them.
+if defined?(Pony)
+  module ::Pony
+    def self.deliveries
+      @deliveries ||= []
+    end
+
+    def self.mail(options)
+      deliveries << build_mail(options)
+    end
+  end
+end

data/lib/tape/cucumber.rb

@@ -0,0 +1,3 @@
+After do
+  Tape.adapter.reset
+end

data/lib/tape/email_spec/address_converter.rb

@@ -0,0 +1,31 @@
+require 'singleton'
+
+module Tape
+  module EmailSpec
+    class AddressConverter
+      include Singleton
+    
+      attr_accessor :converter
+    
+      # The block provided to conversion should convert to an email
+      # address string or return the input untouched. For example:
+      #
+      #  EmailSpec::AddressConverter.instance.conversion do |input|
+      #   if input.is_a?(User)
+      #     input.email
+      #   else
+      #     input
+      #   end
+      #  end
+      #    
+      def conversion(&block)
+        self.converter = block
+      end
+    
+      def convert(input)
+        return input unless converter
+        converter.call(input)
+      end
+    end
+  end
+end

data/lib/tape/email_spec/helpers.rb

@@ -0,0 +1,175 @@
+require 'uri'
+
+module Tape
+
+  module EmailSpec
+
+    module Helpers
+
+      def all_emails
+        Tape.adapter.all
+      end
+
+      def last_email_sent
+        Tape.adapter.last
+      end
+
+      def visit_in_email(link_text)
+        visit(parse_email_for_link(current_email, link_text))
+      end
+
+      def click_email_link_matching(regex, email = current_email)
+        url = links_in_email(email).detect { |link| link =~ regex }
+        raise "No link found matching #{regex.inspect} in #{email.default_part_body}" unless url
+        visit request_uri(url)
+      end
+
+      def click_first_link_in_email(email = current_email)
+        link = links_in_email(email).first
+        visit request_uri(link)
+      end
+
+      def open_email(address, opts={})
+        set_current_email(find_email!(address, opts))
+      end
+
+      alias_method :open_email_for, :open_email
+
+      def open_last_email
+        set_current_email(last_email_sent)
+      end
+
+      def open_last_email_for(address)
+        set_current_email(mailbox_for(address).last)
+      end
+
+      def current_email(address=nil)
+        address = convert_address(address)
+        email = address ? email_spec_hash[:current_emails][address] : email_spec_hash[:current_email]
+        raise RSpec::Expectations::ExpectationNotMetError, "Expected an open email but none was found. Did you forget to call open_email?" unless email
+        email
+      end
+
+      def current_email_attachments(address=nil)
+        current_email(address).attachments || Array.new
+      end
+
+      def unread_emails_for(address)
+        mailbox_for(address) - read_emails_for(address)
+      end
+
+      def read_emails_for(address)
+        email_spec_hash[:read_emails][convert_address(address)] ||= []
+      end
+
+      def find_email(address, opts={})
+        address = convert_address(address)
+        if opts[:with_subject]
+          mailbox_for(address).find { |m| m.subject =~ Regexp.new(opts[:with_subject]) }
+        elsif opts[:with_text]
+          mailbox_for(address).find { |m| m.default_part_body =~ Regexp.new(opts[:with_text]) }
+        else
+          mailbox_for(address).first
+        end
+      end
+
+      def links_in_email(email)
+        URI.extract(email.default_part_body.to_s, ['http', 'https'])
+      end
+
+      private
+
+      def email_spec_hash
+        @email_spec_hash ||= {:read_emails => {}, :unread_emails => {}, :current_emails => {}, :current_email => nil}
+      end
+
+      def find_email!(address, opts={})
+        email = find_email(address, opts)
+        if email.nil?
+          error = "#{opts.keys.first.to_s.humanize unless opts.empty?} #{('"' + opts.values.first.to_s.humanize + '"') unless opts.empty?}"
+          raise   RSpec::Expectations::ExpectationNotMetError, "Could not find email #{error}. \n Found the following emails:\n\n #{all_emails.to_s}"
+         end
+        email
+      end
+
+      def set_current_email(email)
+        return unless email
+        [email.to, email.cc, email.bcc].compact.flatten.each do |to|
+          read_emails_for(to) << email
+          email_spec_hash[:current_emails][to] = email
+        end
+        email_spec_hash[:current_email] = email
+      end
+
+      def parse_email_for_link(email, text_or_regex)
+        email.should have_body_text(text_or_regex)
+
+        url = parse_email_for_explicit_link(email, text_or_regex)
+        url ||= parse_email_for_anchor_text_link(email, text_or_regex)
+
+        raise "No link found matching #{text_or_regex.inspect} in #{email}" unless url
+        url
+      end
+
+      def request_uri(link)
+        return unless link
+        url = URI::parse(link)
+        url.fragment ? (url.request_uri + "#" + url.fragment) : url.request_uri
+      end
+
+      # e.g. confirm in http://confirm
+      def parse_email_for_explicit_link(email, regex)
+        regex = /#{Regexp.escape(regex)}/ unless regex.is_a?(Regexp)
+        url = links_in_email(email).detect { |link| link =~ regex }
+        request_uri(url)
+      end
+
+      # e.g. Click here in  <a href="http://confirm">Click here</a>
+      def parse_email_for_anchor_text_link(email, link_text)
+        if textify_images(email.default_part_body) =~ %r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>}
+          URI.split($1)[5..-1].compact!.join("?").gsub("&amp;", "&")
+          # sub correct ampersand after rails switches it (http://dev.rubyonrails.org/ticket/4002)
+        else
+          return nil
+        end
+      end
+
+      def textify_images(email_body)
+        email_body.to_s.gsub(%r{<img[^>]*alt=['"]?([^'"]*)['"]?[^>]*?/>}) { $1 }
+      end
+
+      def parse_email_count(amount)
+        case amount
+        when "no"
+          0
+        when "an"
+          1
+        else
+          amount.to_i
+        end
+      end
+
+      attr_reader :last_email_address
+
+      def convert_address(address)
+        @last_email_address = (address || current_email_address)
+        AddressConverter.instance.convert(@last_email_address)
+      end
+
+
+      def mailbox_for(address)
+        super(convert_address(address)) # super resides in Deliveries
+      end
+
+      def email_spec_deprecate(text)
+        puts ""
+        puts "DEPRECATION: #{text.split.join(' ')}"
+        puts ""
+      end
+
+    end
+
+  end
+
+end
+

data/lib/tape/email_spec/matchers.rb

@@ -0,0 +1,259 @@
+module Tape
+  module EmailSpec
+    module Matchers
+      class ReplyTo
+        def initialize(email)
+          @expected_reply_to = Mail::ReplyToField.new(email).addrs.first
+        end
+
+        def description
+          "have reply to as #{@expected_reply_to.address}"
+        end
+
+        def matches?(email)
+          @email = email
+          @actual_reply_to = (email.reply_to || []).first
+          !@actual_reply_to.nil? &&
+            @actual_reply_to == @expected_reply_to.address
+        end
+
+        def failure_message
+          "expected #{@email.inspect} to reply to #{@expected_reply_to.address.inspect}, but it replied to #{@actual_reply_to.inspect}"
+        end
+
+        def negative_failure_message
+          "expected #{@email.inspect} not to deliver to #{@expected_reply_to.address.inspect}, but it did"
+        end
+      end
+
+      def reply_to(email)
+        ReplyTo.new(email)
+      end
+
+      alias :have_reply_to :reply_to
+
+      class DeliverTo
+        def initialize(expected_email_addresses_or_objects_that_respond_to_email)
+          emails = expected_email_addresses_or_objects_that_respond_to_email.map do |email_or_object|
+            email_or_object.kind_of?(String) ? email_or_object : email_or_object.email
+          end
+
+          @expected_recipients = Mail::ToField.new(emails).addrs.map(&:to_s).sort
+        end
+
+        def description
+          "be delivered to #{@expected_recipients.inspect}"
+        end
+
+        def matches?(email)
+          @email = email
+          @actual_recipients = (email.header[:to].addrs || []).map(&:to_s).sort
+          @actual_recipients == @expected_recipients
+        end
+
+        def failure_message
+          "expected #{@email.inspect} to deliver to #{@expected_recipients.inspect}, but it delivered to #{@actual_recipients.inspect}"
+        end
+
+        def negative_failure_message
+          "expected #{@email.inspect} not to deliver to #{@expected_recipients.inspect}, but it did"
+        end
+      end
+
+      def deliver_to(*expected_email_addresses_or_objects_that_respond_to_email)
+        DeliverTo.new(expected_email_addresses_or_objects_that_respond_to_email.flatten)
+      end
+
+      alias :be_delivered_to :deliver_to
+
+      class DeliverFrom
+
+        def initialize(email)
+          @expected_sender = Mail::FromField.new(email).addrs.first
+        end
+
+        def description
+          "be delivered from #{@expected_sender}"
+        end
+
+        def matches?(email)
+          @email = email
+          @actual_sender = (email.header[:from].addrs || []).first
+
+          !@actual_sender.nil? &&
+            @actual_sender.to_s == @expected_sender.to_s
+        end
+
+        def failure_message
+          %(expected #{@email.inspect} to deliver from "#{@expected_sender.to_s}", but it delivered from "#{@actual_sender.to_s}")
+        end
+
+        def negative_failure_message
+          %(expected #{@email.inspect} not to deliver from "#{@expected_sender.to_s}", but it did)
+        end
+      end
+
+      def deliver_from(email)
+        DeliverFrom.new(email)
+      end
+
+      alias :be_delivered_from :deliver_from
+
+      class BccTo
+
+        def initialize(expected_email_addresses_or_objects_that_respond_to_email)
+          emails = expected_email_addresses_or_objects_that_respond_to_email.map do |email_or_object|
+            email_or_object.kind_of?(String) ? email_or_object : email_or_object.email
+          end
+
+          @expected_email_addresses = emails.sort
+        end
+
+        def description
+          "be bcc'd to #{@expected_email_addresses.inspect}"
+        end
+
+        def matches?(email)
+          @email = email
+          @actual_recipients = (Array(email.bcc) || []).sort
+          @actual_recipients == @expected_email_addresses
+        end
+
+        def failure_message
+          "expected #{@email.inspect} to bcc to #{@expected_email_addresses.inspect}, but it was bcc'd to #{@actual_recipients.inspect}"
+        end
+
+        def negative_failure_message
+          "expected #{@email.inspect} not to bcc to #{@expected_email_addresses.inspect}, but it did"
+        end
+      end
+
+      def bcc_to(*expected_email_addresses_or_objects_that_respond_to_email)
+        BccTo.new(expected_email_addresses_or_objects_that_respond_to_email.flatten)
+      end
+
+      class CcTo
+
+        def initialize(expected_email_addresses_or_objects_that_respond_to_email)
+          emails = expected_email_addresses_or_objects_that_respond_to_email.map do |email_or_object|
+            email_or_object.kind_of?(String) ? email_or_object : email_or_object.email
+          end
+
+          @expected_email_addresses = emails.sort
+        end
+
+        def description
+          "be cc'd to #{@expected_email_addresses.inspect}"
+        end
+
+        def matches?(email)
+          @email = email
+          @actual_recipients = (Array(email.cc) || []).sort
+          @actual_recipients == @expected_email_addresses
+        end
+
+        def failure_message
+          "expected #{@email.inspect} to cc to #{@expected_email_addresses.inspect}, but it was cc'd to #{@actual_recipients.inspect}"
+        end
+
+        def negative_failure_message
+          "expected #{@email.inspect} not to cc to #{@expected_email_addresses.inspect}, but it did"
+        end
+      end
+
+      def cc_to(*expected_email_addresses_or_objects_that_respond_to_email)
+        CcTo.new(expected_email_addresses_or_objects_that_respond_to_email.flatten)
+      end
+
+        RSpec::Matchers.define :have_subject do
+        match do |given|
+          given_subject = given.subject
+          expected_subject = expected.first
+          
+          if expected_subject.is_a?(String)
+            description { "have subject of #{expected_subject.inspect}" }
+            failure_message_for_should { "expected the subject to be #{expected_subject.inspect} but was #{given_subject.inspect}" }
+            failure_message_for_should_not { "expected the subject not to be #{expected_subject.inspect} but was" }
+
+            given_subject == expected_subject
+          else
+            description { "have subject matching #{expected_subject.inspect}" }
+            failure_message_for_should { "expected the subject to match #{expected_subject.inspect}, but did not.  Actual subject was: #{given_subject.inspect}" }
+            failure_message_for_should_not { "expected the subject not to match #{expected_subject.inspect} but #{given_subject.inspect} does match it." }
+
+            !!(given_subject =~ expected_subject)
+          end
+        end
+      end
+      
+        RSpec::Matchers.define :include_email_with_subject do
+        match do |given_emails|
+          expected_subject = expected.first
+          
+          if expected_subject.is_a?(String)
+            description { "include email with subject of #{expected_subject.inspect}" }
+            failure_message_for_should { "expected at least one email to have the subject #{expected_subject.inspect} but none did. Subjects were #{given_emails.map(&:subject).inspect}" }
+            failure_message_for_should_not { "expected no email with the subject #{expected_subject.inspect} but found at least one. Subjects were #{given_emails.map(&:subject).inspect}" }
+            
+            given_emails.map(&:subject).include?(expected_subject)
+          else
+            description { "include email with subject matching #{expected_subject.inspect}" }
+            failure_message_for_should { "expected at least one email to have a subject matching #{expected_subject.inspect}, but none did. Subjects were #{given_emails.map(&:subject).inspect}" }
+            failure_message_for_should_not { "expected no email to have a subject matching #{expected_subject.inspect} but found at least one. Subjects were #{given_emails.map(&:subject).inspect}" }
+            
+            !!(given_emails.any?{ |mail| mail.subject =~ expected_subject })
+          end
+        end
+      end
+
+        RSpec::Matchers.define :have_body_text do
+        match do |given|
+          expected_text = expected.first
+          
+          if expected_text.is_a?(String)
+            normalized_body = given.default_part_body.to_s.gsub(/\s+/, " ")
+            normalized_expected = expected_text.gsub(/\s+/, " ")
+            description { "have body including #{normalized_expected.inspect}" }
+            failure_message_for_should { "expected the body to contain #{normalized_expected.inspect} but was #{normalized_body.inspect}" }
+            failure_message_for_should_not { "expected the body not to contain #{normalized_expected.inspect} but was #{normalized_body.inspect}" }
+      
+            normalized_body.include?(normalized_expected)
+          else
+            given_body = given.default_part_body.to_s
+            description { "have body matching #{expected_text.inspect}" }
+            failure_message_for_should { "expected the body to match #{expected_text.inspect}, but did not.  Actual body was: #{given_body.inspect}" }
+            failure_message_for_should_not { "expected the body not to match #{expected_text.inspect} but #{given_body.inspect} does match it." }
+      
+            !!(given_body =~ expected_text)
+          end
+        end
+      end
+
+      def mail_headers_hash(email_headers)
+        email_headers.fields.inject({}) { |hash, field| hash[field.field.class::FIELD_NAME] = field.to_s; hash }
+      end
+
+        RSpec::Matchers.define :have_header do
+        match do |given|
+          given_header = given.header
+          expected_name, expected_value = *expected
+
+          if expected_value.is_a?(String)
+            description { "have header #{expected_name}: #{expected_value}" }
+
+            failure_message_for_should { "expected the headers to include '#{expected_name}: #{expected_value}' but they were #{mail_headers_hash(given_header).inspect}" }
+            failure_message_for_should_not { "expected the headers not to include '#{expected_name}: #{expected_value}' but they were #{mail_headers_hash(given_header).inspect}" }
+      
+            given_header[expected_name].to_s == expected_value
+          else
+            description { "have header #{expected_name} with value matching #{expected_value.inspect}" }
+            failure_message_for_should { "expected the headers to include '#{expected_name}' with a value matching #{expected_value.inspect} but they were #{mail_headers_hash(given_header).inspect}" }
+            failure_message_for_should_not { "expected the headers not to include '#{expected_name}' with a value matching #{expected_value.inspect} but they were #{mail_headers_hash(given_header).inspect}" }
+      
+            given_header[expected_name].to_s =~ expected_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tape/email_viewer.rb

@@ -0,0 +1,87 @@
+module EmailSpec
+  class EmailViewer
+    extend Deliveries
+
+    def self.save_and_open_all_raw_emails
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        all_emails.each do |m|
+          f.write m.to_s
+          f.write "\n" + '='*80 + "\n"
+        end
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    def self.save_and_open_all_html_emails
+      all_emails.each_with_index do |m, index|
+        if m.multipart? && html_part = m.parts.detect{ |p| p.content_type == 'text/html' }
+          filename = tmp_email_filename("-#{index}.html")
+          File.open(filename, "w") do |f|
+            f.write m.parts[1].body
+          end
+          open_in_browser(filename)
+        end
+      end
+    end
+
+    def self.save_and_open_all_text_emails
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        all_emails.each do |m|
+          if m.multipart? && text_part = m.parts.detect{ |p| p.content_type == 'text/plain' }
+            m.ordered_each{|k,v| f.write "#{k}: #{v}\n" }
+            f.write text_part.body
+          else
+            f.write m.to_s
+          end
+          f.write "\n" + '='*80 + "\n"
+        end
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    def self.save_and_open_email(mail)
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        f.write mail.to_s
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    def self.save_and_open_email_attachments_list(mail)
+      filename = tmp_email_filename
+
+      File.open(filename, "w") do |f|
+        mail.attachments.each_with_index do |attachment, index|
+          info = "#{index + 1}:"
+          info += "\n\tfilename: #{attachment.original_filename}"
+          info += "\n\tcontent type: #{attachment.content_type}"
+          info += "\n\tsize: #{attachment.size}"
+          f.write info + "\n"
+        end
+      end
+
+      open_in_text_editor(filename)
+    end
+
+    # TODO: use the launchy gem for this stuff...
+    def self.open_in_text_editor(filename)
+      `open #{filename}`
+    end
+
+    def self.open_in_browser(filename)
+      `open #{filename}`
+    end
+
+    def self.tmp_email_filename(extension = '.txt')
+      "#{Rails.root}/tmp/email-#{Time.now.to_i}#{extension}"
+    end
+  end
+end

data/lib/tape/mail_ext.rb

@@ -0,0 +1,15 @@
+require 'mail'
+
+module Tape
+  module MailExt
+    def default_part
+      @default_part ||= html_part || text_part || self
+    end
+
+    def default_part_body
+      default_part.body
+    end
+  end
+end
+
+Mail::Message.send(:include, Tape::MailExt)

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: tape
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexander Flatter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-10 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mail
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: actionmailer
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: actionmailer-maildir
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: ""
+email: 
+- aflatter@farbenmeer.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/tape/adapters/base.rb
+- lib/tape/adapters/action_mailer/test.rb
+- lib/tape/adapters/action_mailer/active_record.rb
+- lib/tape/adapters/action_mailer/cache.rb
+- lib/tape/adapters/action_mailer/maildir.rb
+- lib/tape/adapters/pony.rb
+- lib/tape/email_viewer.rb
+- lib/tape/cucumber.rb
+- lib/tape/adapters.asfdsf
+- lib/tape/mail_ext.rb
+- lib/tape/email_spec/helpers.rb
+- lib/tape/email_spec/address_converter.rb
+- lib/tape/email_spec/matchers.rb
+- lib/tape.rb
+- MIT-LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/aflatter/tape
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: []
+