actionmailer-callbacks 0.0.2 → 1.0.0

data/lib/actionmailer/callbacks/callback.rb

@@ -1,22 +0,0 @@
-module ActionMailer
-  module Callbacks
-    # this object stores the callback data
-    class Callback
-      attr_accessor :name, :except, :only
-
-      def initialize(callback_name, opts={})
-        @name   = callback_name
-        @only   = Array.wrap(opts[:only]).map(&:to_s)
-        @except = Array.wrap(opts[:except]).map(&:to_s)
-      end
-
-      def should_run?(mailer_method)
-        if @only.present?
-          @only.include?(mailer_method.to_s)
-        else
-          !@except.include?(mailer_method.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/actionmailer/callbacks/methods.rb

@@ -1,116 +0,0 @@
-# this implements those class methods to be used in your mailer model:
-# after_create   :do_something
-# before_deliver :log_data
-# after_deliver :log_data, :only   => :notify_customer
-# after_deliver :log_data, :except => [:notify_customer, :send_xmas_regards]
-
-module ActionMailer
-  module Callbacks
-    module Methods
-      CALLBACK_TYPES = %w[before_create after_create before_deliver after_deliver]
-      AROUND_METHODS = %w[around_create around_deliver]
-
-      def self.included(base)
-        base.extend ClassMethods
-        base.alias_method_chain :create!,  :create_callbacks
-        base.alias_method_chain :deliver!, :deliver_callbacks
-      end
-
-      module ClassMethods
-        # this creates a series of methods like these:
-        # def after_create(*args)
-        #   after_create_callbacks << Callback.new(*args)
-        # end
-
-        # def after_create_callbacks
-        #   @after_create_callbacks ||= []
-        # end
-        CALLBACK_TYPES.each do |type|
-          define_method type do |*args|
-            send("#{type}_callbacks") << Callback.new(*args)
-          end
-
-          name = "#{type}_callbacks"
-          define_method name do
-            instance_variable_get("@#{name}") || instance_variable_set("@#{name}", [])
-          end
-        end
-
-        def clear_callbacks
-          CALLBACK_TYPES.each do |type|
-            instance_variable_set "@#{type}_callbacks", []
-          end
-        end
-
-        def around_create(*args)
-          around_create_methods << Callback.new(*args)
-        end
-
-        def around_create_methods
-          @around_create_methods ||= []
-        end
-
-        def around_deliver(*args)
-          around_deliver_methods << Callback.new(*args)
-        end
-
-        def around_deliver_methods
-          @around_deliver_methods ||= []
-        end
-      end
-
-      def create_with_create_callbacks!(*args)
-        @params = args
-        run_around_create_method do
-          run_before_create_callbacks
-          create_without_create_callbacks!(*args)
-          run_after_create_callbacks
-          @mail
-        end
-      end
-
-      def deliver_with_deliver_callbacks!(*args)
-        run_around_deliver_method do
-          run_before_deliver_callbacks
-          deliver_without_deliver_callbacks!(*args)
-          run_after_deliver_callbacks
-          @mail
-        end
-      end
-
-      # this creates a series of methods similar to this:
-      # def run_after_create_callbacks
-      #   self.class.send('after_create_callbacks').each do |callback|
-      #     send callback.name if callback.should_run?(@params.first)
-      #   end
-      # end
-      CALLBACK_TYPES.each do |type|
-        define_method "run_#{type}_callbacks" do
-          self.class.send("#{type}_callbacks").each do |callback|
-            send callback.name if callback.should_run?(@params.first)
-          end
-        end
-      end
-
-      def run_around_create_method(&block)
-        self.class.send('around_create_methods').each do |callback|
-          if callback.should_run?(@params.first)
-            send callback.name, &block
-            return
-          end
-        end
-        block.call
-      end
-
-      def run_around_deliver_method(&block)
-        self.class.send('around_deliver_methods').each do |callback|
-          if callback.should_run?(@params.first)
-            send callback.name, &block
-            return
-          end
-        end
-        block.call
-      end
-    end
-  end
-end

data/spec/callback_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe ActionMailer::Callbacks::Callback do
-  describe 'a new callback' do
-    let(:callback) { ActionMailer::Callbacks::Callback.new('name', :except => ['except', :notthis], :only => :yesthis) }
-
-    it 'should have "name", "except", "only" accessors' do
-      %w[name except only].each do |attribute|
-        callback.send "#{attribute}=", 'asd'
-        callback.send(attribute).should == 'asd'
-      end
-    end
-
-    it 'should stringify symbols in "except" and "only" arrays' do
-      callback.instance_eval do
-        @except.should == ['except', 'notthis']
-      end
-    end
-  end
-
-  describe 'should_run?' do
-    context 'when "except" is set' do
-      let(:callback) { ActionMailer::Callbacks::Callback.new('name', :except => ['except']) }
-      it 'should be false for except' do
-        callback.should_run?('except').should be_false
-      end
-
-      it 'be true for anything else' do
-        callback.should_run?('other').should be_true
-      end
-    end
-
-    context 'when "only" is set' do
-      let(:callback) { ActionMailer::Callbacks::Callback.new('name', :only => :this_method_name)}
-
-      it 'should be be true for this_method_name' do
-        callback.should_run?('this_method_name').should be_true
-      end
-
-      it 'should be be false for anything else' do
-        callback.should_run?('another_method_name').should be_false
-      end
-    end
-
-    context 'when neither "except" or "only" are set' do
-      let(:callback) { ActionMailer::Callbacks::Callback.new('name') }
-
-      it 'should be true for any method' do
-        callback.should_run?('any_method_name').should be_true
-      end
-    end
-  end
-end

data/spec/fixtures/mailer_with_callbacks.rb

@@ -1,49 +0,0 @@
-class MailerWithCallbacks < ActionMailer::Base
-  before_create  :set_before_create_flag,  :except => :no_callback
-  after_create   :set_after_create_flag,   :except => [:no_callback]
-  before_deliver :set_before_deliver_flag, :only   => :test_email
-  after_deliver  :set_after_deliver_flag
-  around_create  :create_wrapper_flag
-  around_deliver :deliver_wrapper_flag
-
-  def test_email(recipient)
-    recipients recipient
-     from      'test@test.com'
-     subject   'test email'
-     body      'a test email'
-  end
-
-  def no_callback(recipient)
-    test_email(recipient)
-  end
-
-  private
-
-    def create_wrapper_flag
-      Flag.create_before_block_call = true
-      yield
-      Flag.create_after_block_call = true
-    end
-
-    def deliver_wrapper_flag
-      Flag.deliver_before_block_call = true
-      yield
-      Flag.deliver_after_block_call = true
-    end
-
-    def set_before_create_flag
-      Flag.before_create = true
-    end
-
-    def set_after_create_flag
-      Flag.after_create = true
-    end
-
-    def set_before_deliver_flag
-      Flag.before_deliver = true
-    end
-
-    def set_after_deliver_flag
-      Flag.after_deliver = true
-    end
-end

data/spec/fixtures/mailer_without_callbacks.rb

@@ -1,8 +0,0 @@
-class MailerWithoutCallbacks < ActionMailer::Base
-  def test_email(recipient)
-    recipients recipient
-     from      'test@test.com'
-     subject   'test email'
-     body      'a test email'
-  end
-end

data/spec/integration/action_mailer_integration_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-
-describe MailerWithCallbacks do
-  before { Flag.reset }
-
-  context 'when delivering a mail via deliver_* class method' do
-    context 'when the mailer method has callbacks' do
-      before { MailerWithCallbacks.deliver_test_email('asd@asd.it') }
-
-      it 'should run before_create callback' do
-        Flag.before_create.should be_true
-      end
-
-      it 'should run after_create callback' do
-        Flag.after_create.should be_true
-      end
-
-      it 'should run before_deliver callback' do
-        Flag.before_deliver.should be_true
-      end
-
-      it 'should run after_deliver callback' do
-        Flag.after_deliver.should be_true
-      end
-
-      it 'should run around_create method' do
-        Flag.create_before_block_call.should be_true
-        Flag.create_after_block_call.should be_true
-      end
-
-      it 'should run around_deliver method' do
-        Flag.deliver_before_block_call.should be_true
-        Flag.deliver_after_block_call.should be_true
-      end
-    end
-
-    context 'when the mailer method is included in only/except options' do
-      before { MailerWithCallbacks.deliver_no_callback('asd@asd.it') }
-
-      it 'should not run the callback when in except' do
-        Flag.after_create.should_not be_true
-      end
-
-      it 'should not run the callback when not in only' do
-        Flag.before_deliver.should_not be_true
-      end
-    end
-
-    context 'when the mailer method is not included in any restricting options' do
-      before { MailerWithCallbacks.deliver_test_email('asd@asd.it') }
-
-      it 'should run after_deliver callback' do
-        Flag.after_deliver.should be_true
-      end
-    end
-
-    context 'when error is raised on delivery' do
-      before do
-        MailerWithCallbacks.any_instance.should_receive(:deliver_without_deliver_callbacks!).and_raise(ArgumentError)
-        MailerWithCallbacks.deliver_test_email('asd@asd.it') rescue nil
-      end
-
-      it 'should run before_create callback' do
-        Flag.before_create.should be_true
-      end
-
-      it 'should run after_create callback' do
-        Flag.after_create.should be_true
-      end
-
-      it 'should run before_deliver callback' do
-        Flag.before_deliver.should be_true
-      end
-
-      it 'should not run after_deliver callback' do
-        Flag.after_deliver.should_not be_true
-      end
-    end
-
-    context 'when error is raised on creation' do
-      context 'when error is raised on delivery' do
-        before do
-          MailerWithCallbacks.any_instance.should_receive(:create_without_create_callbacks!).and_raise(ArgumentError)
-          MailerWithCallbacks.create_test_email('asd@asd.it') rescue nil
-        end
-
-        it 'should run before_create callback' do
-          Flag.before_create.should be_true
-        end
-
-        it 'should not run after_create callback' do
-          Flag.after_create.should_not be_true
-        end
-
-        it 'should not run before_deliver callback' do
-          Flag.before_deliver.should_not be_true
-        end
-
-        it 'should not run after_deliver callback' do
-          Flag.after_deliver.should_not be_true
-        end
-      end
-    end
-  end
-
-  context 'when creating a mail via create_* class method' do
-    before { MailerWithCallbacks.create_test_email('asd@asd.it') }
-
-    it 'should run before_create callback' do
-      Flag.before_create.should be_true
-    end
-
-    it 'should run after_create callback' do
-      Flag.after_create.should be_true
-    end
-
-    it 'should not run before_deliver callback' do
-      Flag.before_deliver.should_not be_true
-    end
-
-    it 'should not run after_deliver callback' do
-      Flag.after_deliver.should_not be_true
-    end
-
-    it 'should run around_create method' do
-      Flag.create_before_block_call.should be_true
-      Flag.create_after_block_call.should be_true
-    end
-
-    it 'should not run around_deliver method' do
-      Flag.deliver_before_block_call.should_not be_true
-      Flag.deliver_after_block_call.should_not be_true
-    end
-  end
-end

data/spec/methods_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe ActionMailer::Callbacks::Methods do
-  def callback_lists
-    %w[before_create_callbacks after_create_callbacks before_deliver_callbacks after_deliver_callbacks]
-  end
-
-  before { MailerWithoutCallbacks.clear_callbacks }
-
-  it 'callbacks lists should be empty' do
-    callback_lists.each do |list|
-      MailerWithoutCallbacks.send(list).should be_empty
-    end
-  end
-
-  context 'when adding a after create callback' do
-    before do
-      MailerWithoutCallbacks.before_create('name')
-      MailerWithoutCallbacks.after_create('name')
-      MailerWithoutCallbacks.before_deliver('name')
-      MailerWithoutCallbacks.after_deliver('name')
-    end
-
-    it 'should add the callbacks to the list' do
-      callback_lists.each do |list|
-        MailerWithoutCallbacks.send(list).should have(1).item
-      end
-    end
-
-    it 'clear_callbacks should clear all lists' do
-      MailerWithoutCallbacks.clear_callbacks
-      callback_lists.each do |list|
-        MailerWithoutCallbacks.send(list).should be_empty
-      end
-    end
-  end
-
-  describe 'when delivering a mail via method missing' do
-    it 'should call before_create callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_receive(:run_before_create_callbacks)
-      MailerWithoutCallbacks.deliver_test_email('asd@asd.it')
-    end
-
-    it 'should call after_create callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_receive(:run_after_create_callbacks)
-      MailerWithoutCallbacks.deliver_test_email('asd@asd.it')
-    end
-
-    it 'should call before_deliver callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_receive(:run_before_deliver_callbacks)
-      MailerWithoutCallbacks.deliver_test_email('asd@asd.it')
-    end
-
-    it 'should call after_deliver callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_receive(:run_after_deliver_callbacks)
-      MailerWithoutCallbacks.deliver_test_email('asd@asd.it')
-    end
-
-  end
-
-  describe 'when creating a mail via method_missing' do
-    it 'should call before_create callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_receive(:run_before_create_callbacks)
-      MailerWithoutCallbacks.create_test_email('asd@asd.it')
-    end
-
-    it 'should call after_create callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_receive(:run_after_create_callbacks)
-      MailerWithoutCallbacks.create_test_email('asd@asd.it')
-    end
-
-    it 'should not call before_deliver callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_not_receive(:run_before_deliver_callbacks)
-      MailerWithoutCallbacks.create_test_email('asd@asd.it')
-    end
-
-    it 'should not call after_deliver callback handing method' do
-      MailerWithoutCallbacks.any_instance.should_not_receive(:run_after_deliver_callbacks)
-      MailerWithoutCallbacks.create_test_email('asd@asd.it')
-    end
-  end
-end