thorero-mailer 0.9.4

data/lib/merb-mailer/mailer.rb

@@ -0,0 +1,104 @@
+begin
+  require 'mailfactory'
+  require 'net/smtp'
+rescue LoadError
+  Merb.logger.warn "You need to install the mailfactory gem to use Merb::Mailer"
+end  
+
+class MailFactory
+  attr_reader :html, :text
+end
+
+module Merb
+
+  # You'll need a simple config like this in init.rb if you want
+  # to actually send mail:
+  #
+  #   Merb::Mailer.config = {
+  #     :host   => 'smtp.yourserver.com',
+  #     :port   => '25',              
+  #     :user   => 'user',
+  #     :pass   => 'pass',
+  #     :auth   => :plain # :plain, :login, :cram_md5, the default is no auth
+  #     :domain => "localhost.localdomain" # the HELO domain provided by the client to the server 
+  #   }
+  # 
+ 	#   or 
+ 	# 
+ 	#   Merb::Mailer.config = {:sendmail_path => '/somewhere/odd'}
+  #   Merb::Mailer.delivery_method = :sendmail
+  #
+  # You could send mail manually like this (but it's better to use
+  # a MailController instead).
+  # 
+  #   m = Merb::Mailer.new :to => 'foo@bar.com',
+  #                        :from => 'bar@foo.com',
+  #                        :subject => 'Welcome to whatever!',
+  #                        :body => partial(:sometemplate)
+  #   m.deliver!                     
+
+  class Mailer
+
+    class_inheritable_accessor :config, :delivery_method, :deliveries
+    attr_accessor :mail
+    self.deliveries = []
+
+    # Sends the mail using sendmail.
+    def sendmail
+      sendmail = IO.popen("#{config[:sendmail_path]} #{@mail.to}", 'w+') 
+      sendmail.puts @mail.to_s
+      sendmail.close
+    end
+
+    # Sends the mail using SMTP.
+    def net_smtp
+      Net::SMTP.start(config[:host], config[:port].to_i, config[:domain], 
+                      config[:user], config[:pass], config[:auth]) { |smtp|
+        smtp.send_message(@mail.to_s, @mail.from.first, @mail.to.to_s.split(/[,;]/))
+      }
+    end
+
+    # Tests mail sending by adding the mail to deliveries.
+    def test_send
+      deliveries << @mail
+    end
+
+    # Delivers the mail with the specified delivery method, defaulting to
+    # net_smtp.
+    def deliver!
+      send(delivery_method || :net_smtp)
+    end
+
+    # ==== Parameters
+    # file_or_files<File, Array[File]>:: File(s) to attach.
+    # filename<String>::
+    # type<~to_s>::
+    #   The attachment MIME type. If left out, it will be determined from
+    #   file_or_files.
+    # headers<String, Array>:: Additional attachment headers.
+    #
+    # ==== Raises
+    # ArgumentError::
+    #   file_or_files was not a File or an Array of File instances.
+    def attach(file_or_files, filename = file_or_files.is_a?(File) ? File.basename(file_or_files.path) : nil, 
+      type = nil, headers = nil)
+      if file_or_files.is_a?(Array)
+        file_or_files.each {|k,v| @mail.add_attachment_as k, *v}
+      else
+        raise ArgumentError, "You did not pass in a file. Instead, you sent a #{file_or_files.class}" if !file_or_files.is_a?(File)
+        @mail.add_attachment_as(file_or_files, filename, type, headers)
+      end
+    end
+      
+    # ==== Parameters
+    # o<Hash{~to_s => Object}>:: Configuration commands to send to MailFactory.
+    def initialize(o={})
+      self.config = {:sendmail_path => '/usr/sbin/sendmail'} if config.nil? 
+      o[:rawhtml] = o.delete(:html)
+      m = MailFactory.new()
+      o.each { |k,v| m.send "#{k}=", v }
+      @mail = m
+    end
+    
+  end
+end

data/lib/merb-mailer/mailer_mixin.rb

@@ -0,0 +1,25 @@
+module Merb
+  module MailerMixin
+    
+    # Sends mail via a MailController (a tutorial can be found in the
+    # MailController docs).
+    #
+    # ==== Parameters
+    # klass<Class>:: The mailer class.
+    # method<~to_s>:: The method to call on the mailer.
+    # mail_params<Hash>::
+    #   Mailing parameters, e.g. :to and :cc. See
+    #   Merb::MailController#dispatch_and_deliver for details.
+    # send_params<Hash>::
+    #   Params to send to the mailer. Defaults to the params of the current
+    #   controller.
+    #
+    # ==== Examples
+    #   # Send an email via the FooMailer's bar method.
+    #   send_mail FooMailer, :bar, :from => "foo@bar.com", :to => "baz@bat.com"
+    def send_mail(klass, method, mail_params, send_params = nil)
+      klass.new(send_params || params, self).dispatch_and_deliver(method, mail_params)
+    end
+      
+  end
+end

data/merb_generators/mail_controller/USAGE

@@ -0,0 +1 @@
+merb-gen mail_controller <name> <meth1> <meth2>

data/merb_generators/mail_controller/mail_controller_generator.rb

@@ -0,0 +1,59 @@
+require "merb-gen/helpers"
+require "merb-gen/base"
+
+class MailControllerGenerator < Merb::GeneratorBase
+  
+  attr_reader :controller_class_name, 
+              :controller_file_name, 
+              :controller_base_path,
+              :controller_modules,
+              :full_controller_const
+  
+  def initialize(args, runtime_args = {})
+    @base =             File.dirname(__FILE__)
+    super
+    name = args.shift
+    @controller_file_name   = name.snake_case.gsub("::", "/")
+    
+    # Need to setup the directories
+    unless @controller_file_name == File.basename(@controller_file_name)
+      @controller_base_path   = controller_file_name.split("/")[0..-2].join("/") 
+    end
+    
+    @controller_modules     = @controller_file_name.to_const_string.split("::")[0..-2]
+    @controller_class_name  = @controller_file_name.to_const_string.split("::").last
+    
+    @full_controller_const = ((@controller_modules.dup || []) << @controller_class_name).join("::")
+  end
+  
+  def manifest
+    record do |m|
+      @m = m
+      
+      # Create the controller directory
+      m.directory File.join("app/mailers", controller_base_path) if controller_base_path
+      
+      @assigns =  {
+                    :controller_modules    => controller_modules,
+                    :controller_class_name => controller_class_name,
+                    :controller_file_name  => controller_file_name,
+                    :controller_base_path  => controller_base_path,
+                    :full_controller_const => full_controller_const
+                  }
+      
+      copy_dirs
+      copy_files
+      
+    end
+  end
+  
+  protected
+  def banner
+    <<-EOS.split("\n").map{|x| x.strip}.join("\n")
+      Creates a Merb mail controller stub.
+
+      USAGE: #{spec.name} mail_controller_name"
+    EOS
+  end  
+  
+end

data/merb_generators/mail_controller/templates/app/mailers/%controller_file_name%_mailer.rb

@@ -0,0 +1,20 @@
+<% counter = 0 -%>
+<% controller_modules.each_with_index do |mod, i| -%>
+<%= "  " * i %>module <%= mod %>
+<% counter = i -%>
+<% end -%>
+<% counter = counter == 0 ? 0 : (counter + 1) -%>
+<%= "  " * counter %>class <%= controller_class_name %>Mailer < Merb::MailController
+  
+<%= "  " * counter %>  def notify_on_event
+<%= "  " * counter %>    # use params[] passed to this controller to get data
+<%= "  " * counter %>    # read more at http://wiki.merbivore.com/pages/mailers
+<%= "  " * counter %>    render_mail
+<%= "  " * counter %>  end
+  
+<%= "  " * counter %>end
+<% counter = counter == 0 ? 0 : (counter - 1) -%>
+<% controller_modules.reverse.each_with_index do |mod, i| -%>
+<%= "  " * counter %>end # <%= mod %>
+<% counter = counter - 1 -%>
+<% end -%>

data/merb_generators/mail_controller/templates/app/mailers/views/%controller_file_name%_mailer/notify_on_event.text.erb

@@ -0,0 +1 @@
+Sample template for plain text email.

data/merb_generators/mail_controller/templates/spec/mailers/%controller_file_name%_mailer_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+# Move this to your spec_helper.rb.
+module MailControllerTestHelper
+  # Helper to clear mail deliveries.
+  def clear_mail_deliveries
+    Merb::Mailer.deliveries.clear
+  end
+
+  # Helper to access last delivered mail.
+  # In test mode merb-mailer puts email to
+  # collection accessible as Merb::Mailer.deliveries.
+  def last_delivered_mail
+    Merb::Mailer.deliveries.last
+  end
+
+  # Helper to deliver
+  def deliver(action, mail_params = {}, send_params = {})
+    <%= controller_class_name %>Mailer.dispatch_and_deliver(action, { :from => "no-reply@webapp.com", :to => "recepient@person.com" }.merge(mail_params), send_params)
+    @delivery = last_delivered_mail
+  end
+end
+
+describe <%= controller_class_name %>Mailer, "#notify_on_event email template" do
+  include MailControllerTestHelper
+  
+  before :each do
+    clear_mail_deliveries
+    
+    # instantiate some fixture objects
+  end
+    
+  it "includes welcome phrase in email text" do
+    voilated "Mailer controller deserves to have specs, too."
+    
+    # <%= controller_class_name %>Mailer.dispatch_and_deliver(:notify_on_event, {}, { :name => "merb-mailer user" })
+    # last_delivered_mail.text.should =~ /Hello, merb-mailer user!/
+  end
+end

data/spec/mail_controller_spec.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+Spec::Runner.configure do |config|
+  config.include Merb::Test::RequestHelper  
+end
+
+class Merb::Mailer
+  self.delivery_method = :test_send
+end
+
+Merb.push_path(:mailer, File.join(File.dirname(__FILE__), "mailers"))
+
+class TestMailController < Merb::MailController
+  
+  def first
+    render_mail
+  end
+  
+  def second
+    render_mail
+  end
+  
+  def third
+    render_mail :text => :first, :html => :third
+  end
+  
+  def fourth
+    render_mail :text => "FOURTH_TEXT", :html => "FOURTH_HTML", :layout => :none
+  end
+  
+  def fifth
+    render_mail :action => {:text => :first, :html => :third}
+  end
+  
+  def sixth
+    render_mail :action => {:text => :first}, :html => "SIXTH_HTML"
+  end
+  
+  def seventh
+    render_mail :text => :first, :html => "SEVENTH_HTML"
+  end
+  
+  def eighth
+    @testing = "TEST"
+    render_mail
+  end
+  
+  def ninth
+    render_mail
+  end
+  
+  def tenth
+    render_mail
+  end
+  
+end
+
+class TestController < Merb::Controller
+  
+  def one
+    send_mail TestMailController, :ninth, {:from => "foo@bar.com", :to => "foo@bar.com"}, {:x => "ONE_CONTROLLER"}
+  end
+  
+end
+
+describe "A Merb Mail controller" do
+  
+  def deliver(action)
+    TestMailController.dispatch_and_deliver action, :from => "foo@bar.com", :to => "foo@bar.com"
+    @delivery = Merb::Mailer.deliveries.last
+  end
+
+  undef :call_action if defined?(call_action)
+  def call_action(action)
+    dispatch_to(TestController, action)
+    @delivery = Merb::Mailer.deliveries.last  
+  end
+  
+  it "should render files in its directory by default" do
+    deliver :first
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+  end
+  
+  it "should render files in its directory without a mimetype extension by default" do
+    deliver :second
+    @delivery.text.should == "TEXT\nSECOND\nENDTEXT"
+  end
+  
+  it "should be able to accept a :text => :sym, :html => :sym render_mail" do
+    deliver :third
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "BASIC\nTHIRDHTML\nLAYOUT"
+  end
+  
+  it "should be able to accept a :text => STRING, :html => STRING render_mail" do
+    deliver :fourth
+    $DEBUGGER = true
+    @delivery.text.should == "FOURTH_TEXT"
+    @delivery.html.should == "FOURTH_HTML"    
+    $DEBUGGER = false
+  end
+  
+  it "should be able to accept an :action => {:text => :sym, :html => :sym}" do
+    deliver :fifth
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "BASIC\nTHIRDHTML\nLAYOUT"    
+  end
+  
+  it "should be able to accept a mix of action and :html => STRING" do
+    deliver :sixth
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "SIXTH_HTML"    
+  end
+  
+  it "should be able to accept a mix of :text => :sym and :html => STRING" do
+    deliver :seventh
+    @delivery.text.should == "TEXT\nFIRST\nENDTEXT"
+    @delivery.html.should == "SEVENTH_HTML"    
+  end
+  
+  it "should hold onto instance variables" do
+    deliver :eighth
+    @delivery.html.should == "BASIC\nTEST\nLAYOUT"    
+  end
+  
+  it "should have access to the params sent by the calling controller" do
+    call_action :one
+    @delivery.html.should == "BASIC\nONE_CONTROLLER\nLAYOUT"    
+  end
+  
+  it "should not raise an error if there are no templates" do
+    lambda do
+      deliver :tenth    
+    end.should_not raise_error
+  end
+  
+  it "should log an error if there are no templates available" do
+    Merb.logger.should_receive(:error).once
+    deliver :tenth
+  end
+  
+end
+
+# describe "Merb::MailController with url generation" do
+#   
+#   it_should_behave_like "class with general url generation"
+#   it_should_behave_like "non routeable controller with url mixin"
+#   
+#   def new_url_controller(route, params = {:action => 'show', :controller => 'Test'})
+#     request = OpenStruct.new
+#     request.route = route
+#     request.params = params
+#     response = OpenStruct.new
+#     response.read = ""
+#     
+#     @controller = Merb::Controller.build(request, response)
+#     TestMailController.new(params, @controller)
+#   end
+#   
+#   it "should raise an error if no controller is specified and the base controller is not set" do
+#     c = new_url_controller(@default_route, {})    
+#     lambda do
+#       the_url = c.url(:action => "bar")
+#     end.should raise_error
+#   end
+#   
+#   it "should use the base controller when it is set to generate a url when no :controller option is specified" do
+#     c = new_url_controller(@defualt_route, :controller => "foo")
+#     lambda do
+#       the_url = c.url(:action => "bar")
+#       the_url.should == "/foo/bar"
+#     end.should_not raise_error    
+#   end
+# end

data/spec/mailer_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class TestMailer < Merb::Mailer
+  self.delivery_method = :test_send
+end
+
+class TestSMTPMailer < Merb::Mailer
+  self.delivery_method = :net_smtp
+  self.config = { :host     => 'smtp.yourserver.com',
+                  :port     => '25',              
+                  :user     => 'user',
+                  :pass     => 'pass',
+                  :auth     => :plain }
+                  
+end
+
+class TestSendmailMailer < Merb::Mailer
+  self.delivery_method = :sendmail
+end
+
+def setup_test_mailer klass = TestMailer
+  @m = klass.new :to      => "test@test.com",
+                 :from    => "foo@bar.com",
+                 :subject => "Test Subject",
+                 :body    => "Test"    
+end
+
+describe "a merb mailer" do
+  
+  it "should be able to send test emails" do
+    setup_test_mailer
+    @m.deliver!
+    TestMailer.deliveries.size.should == 1
+    delivery = TestMailer.deliveries.last
+    delivery.to.should include("test@test.com")
+    delivery.from.should include("foo@bar.com")
+    delivery.subject.should include("=?utf-8?Q?Test_Subject=?=")
+    delivery.body.should include("Test")
+  end
+  
+  it "should be able to accept attachments" do
+    setup_test_mailer
+    @m.attach File.open("README")
+    @m.deliver!
+    delivery = TestMailer.deliveries.last
+    delivery.instance_variable_get("@attachments").size.should == 1
+  end
+  
+  it "should be able to accept multiple attachments" do
+    setup_test_mailer
+    @m.attach [[File.open("README")], [File.open("LICENSE")]]
+    @m.deliver!
+    delivery = TestMailer.deliveries.last
+    delivery.instance_variable_get("@attachments").size.should == 2    
+  end
+  
+  it "should be able to send mails via SMTP" do
+    setup_test_mailer TestSMTPMailer
+    Net::SMTP.stub!(:start).and_return(true)
+    Net::SMTP.should_receive(:start).with("smtp.yourserver.com", 25, nil, "user", "pass", :plain)
+    @m.deliver!
+  end
+  
+  it "should send mails via SMTP with no auth" do
+    setup_test_mailer TestSMTPMailer
+    @m.config[:auth] = nil
+    Net::SMTP.stub!(:start).and_return(true)
+    Net::SMTP.should_receive(:start).with("smtp.yourserver.com", 25, nil, "user", "pass", nil)
+    @m.deliver!
+  end
+  
+  it "should be able to send mails via sendmail" do
+    sendmail = mock("/usr/sbin/sendmail", :null_object => true) 
+    setup_test_mailer TestSendmailMailer
+    IO.should_receive(:popen).with("/usr/sbin/sendmail #{@m.mail.to}", "w+").and_return(sendmail) 
+    @m.deliver!
+  end  
+  
+  it "should be able to use a different sendmail path" do 
+ 	  sendmail = mock("/somewhere/sendmail", :null_object => true) 
+ 	  setup_test_mailer TestSendmailMailer 
+ 	  @m.config[:sendmail_path] = '/somewhere/sendmail' 
+ 	  IO.should_receive(:popen).with("/somewhere/sendmail #{@m.mail.to}", "w+").and_return(sendmail) 
+ 	  @m.deliver! 
+ 	end
+  
+end