actionmailer-callbacks 1.0.0 → 1.1.0

data/{.travis → .travis.yml}

@@ -1,3 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
 branches:
   only:
     - master

data/README.md

@@ -2,22 +2,24 @@
 
 [![Build Status](https://secure.travis-ci.org/spaghetticode/actionmailer-callbacks.png)](http://travis-ci.org/spaghetticode/actionmailer-callbacks)
 
-This gem adds before_create and around_create to ActionMailer::Base to make it
-work similarly to ActionController before/around filters and ActiveRecord::Base
-callbacks:
+This gem adds ```before_create``` and ```around_create``` to ActionMailer::Base
+to  make it work similarly to ActionController before/around filters and
+ActiveRecord::Base callbacks:
 
 ```ruby
-  before_create  :log_params, except: :test_email
-  around_create  :benchmark,  only:   :test_email
+  before_create :log_params, except: :test_email
+  around_create :benchmark,  only:   :test_email
 ```
 
-*except* and *only* options are optional and has same functionality as in
+```except``` and ```only``` options are optional and has same functionality as in
 ActionController.
 
+Callbacks functionality is implemented using the ActiveSupport::Callbacks module.
+
 
 ## Requirements
 
-The master branch now works only with Actionmailer 3.x, if you need to add
+The master branch now works only with ActionMailer 3.x, if you need to add
 callbacks to older versions please refer to the 0.x release.
 
 
@@ -31,24 +33,29 @@ Add the gem to the Gemfile:
 
 And then run ```bundle```
 
->>>>>>> actionmailer3
+
+## Documentation
+
+You can find some more documentation on the workings of the gem on relish:
+https://www.relishapp.com/spaghetticode/actionmailer-callbacks/docs
+
 
 ## Notes
 
 If you need something like before/after deliver callbacks ActionMailer 3.x comes
-ready for that: you can use an *observer* or an *instrumentation* for that.
+ready for that: you can use an **observer** or an **instrumentation** for that.
 
-*around_create* wrap the mail method execution (and all before_create callbacks).
-You can use them for rescuing from errors or for benchmarking, for example.
-There can be only one *around_create* method for each email method, if you
-register more than one only the first will be executed.
+The **around_create** callback wraps the entire mail method execution. You can
+use them for rescuing from errors or for benchmarking, for example.
 
+The gem adds the ```args``` attribute accessor to the mail object in order to
+be able to access the arguments used for its initialization.
 
 ## Example
 
 ```ruby
   class UserMailer < ActionMailer::Base
-    before_create :log_params
+    before_create :log_args
     around_create :rescue_from_errors
 
     def user_registration(user)
@@ -57,7 +64,7 @@ register more than one only the first will be executed.
 
     private
 
-    def log_params(args)
+    def log_args
       MailerLogger.info "[CREATE] #{args.inspect}"
     end
 

data/Rakefile

@@ -11,4 +11,27 @@ task :spec do
   end
 end
 
-task :default => :spec
+desc 'Run cucumber features'
+task :cucumber do
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new do |t|
+    t.rcov = false
+  end
+end
+
+desc 'Runs tests on Travis CI'
+task :travis do
+  ["rspec spec", "rake cucumber"].each do |cmd|
+    puts "Starting to run #{cmd}..."
+    system("export DISPLAY=:99.0 && bundle exec #{cmd}")
+    raise "#{cmd} failed!" unless $?.exitstatus == 0
+  end
+end
+
+if ENV['TRAVIS']
+  task :default => :travis
+else
+  task :default => [:spec, :cucumber]
+end
+

data/actionmailer-callbacks.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = 'actionmailer-callbacks'
   gem.require_paths = ["lib"]
-  gem.version       = Actionmailer::Callbacks::VERSION
+  gem.version       = ActionMailer::Callbacks::VERSION
 
   gem.add_dependency 'actionmailer', '~> 3.0'
   gem.add_dependency 'activesupport'

data/features/around_create_callback.feature

@@ -1,19 +1,22 @@
 Feature: around_create callback
   As an actionmailer gem user
-  I want to be able to use the around_create callback
-  So that I can wrap the email creation process with my callback
+  I want to be able to use the *around_create* callback
+  so that I can wrap the email creation process with my callback.
 
-    The "around_create" callback allows to wrap the email creation
+    The *around_create* callback allows to wrap the email creation
     process around another method definition.
+
     The macro accepts the callback name as first arguments and an
-    optional hash with "only" and/or "except" keys that are
-    functionally equivalent to the ones of ActionController
+    optional hash with *only* and/or *except* keys that are
+    functionally equivalent to the ones of ApplicationController
     before/after/around create filters: for example in order
     to run a callback only for the "test" action you should
     specify one of the following:
+
       around_create :test_callback, only: :test
       around_create :test_callback, only: [:test]
-@focus
+
+
 Scenario: successful around_create calling
   Given the following mailer class with an around_create callback:
     """
@@ -34,8 +37,9 @@ Scenario: successful around_create calling
 
       private
 
-      def log_args(*args)
-        self.class.logger << "Test email now being called with #{args.flatten.inspect}"
+      def log_args
+        params = args.flatten.to_sentence
+        self.class.logger << "Test email now being called with #{params}"
         yield
         self.class.logger << "Test email was successfully created"
       end
@@ -45,13 +49,14 @@ Scenario: successful around_create calling
   Then an email should have been created
   And the logger for the class "TestMailer" should contain:
     """
-    Test email now being called with ["recipient@test.com"]
+    Test email now being called with test and recipient@test.com
     """
   And the logger for the class "TestMailer" should contain:
     """
     Test email was successfully created
     """
 
+
   Scenario: around_create callback skipped because not included in "only" directive
     Given the following mailer class with an around_create callback:
       """
@@ -82,3 +87,35 @@ Scenario: successful around_create calling
     When I run the code "TestMailer.test('recipient@test.com')"
     Then an email should have been created
     And the logger for the class "TestMailer" should be empty
+
+
+  Scenario: around_create callback skipped because included in "except" directive
+    Given the following mailer class with an around_create callback:
+      """
+      class TestMailer < ::ActionMailer::Base
+        around_create :log_args, except: :test
+
+        def self.logger
+          @logger ||= Array.new
+        end
+
+        def test(recipient)
+          mail(
+            to: recipient,
+            from: 'sender@test.com',
+            subject: 'Test Email'
+          )
+        end
+
+        private
+
+        def log_args(*args)
+          self.class.logger << "Test email now being called"
+          yield
+          self.class.logger << "Test email was successfully created"
+        end
+      end
+      """
+    When I run the code "TestMailer.test('recipient@test.com')"
+    Then an email should have been created
+    And the logger for the class "TestMailer" should be empty

data/features/before_create_callback.feature

@@ -1,19 +1,21 @@
 Feature: before_create callback
   As an actionmailer gem user
   I want to be able to use the before_create callback
-  So that I can to execute code before creating an email
+  so that I can to execute code before creating an email
 
-    The "before_create" callback allows to execute a callback
+    The *before_create* callback allows to execute a callback
     before the email creation process. The macro accepts
     the callback name as first arguments and an
-    optional hash with "only" and/or "except" keys that are
-    functionally equivalent to the ones of ActionController
+    optional hash with *only* and/or *except* keys that are
+    functionally equivalent to the ones of ApplicationController
     before/after/around create filters: for example in order
-    to run a callback only for the "test" action you should
+    to run a callback only for the *test* action you should
     specify one of the following:
+
       before_create :test_callback, only: :test
       before_create :test_callback, only: [:test]
 
+
 Scenario: successful before_create callback calling
   Given the following mailer class with a before_create callback:
     """
@@ -34,8 +36,8 @@ Scenario: successful before_create callback calling
 
       private
 
-      def log_args(args)
-        self.class.logger << "Test was called with #{args.inspect}"
+      def log_args
+        self.class.logger << "Test was called with #{args.to_sentence}"
       end
     end
     """
@@ -43,9 +45,10 @@ Scenario: successful before_create callback calling
   Then an email should have been sent
   And the logger for the class "TestMailer" should contain:
     """
-    Test was called with "recipient@test.com"
+    Test was called with test and recipient@test.com
     """
 
+
   Scenario: before_create callback skipped because not included in "only" directive
     Given the following mailer class with a before_create callback:
       """
@@ -66,8 +69,38 @@ Scenario: successful before_create callback calling
 
         private
 
-        def log_args(*args)
-          self.class.logger << "Test was called with #{args.inspect}"
+        def log_args
+          self.class.logger << "Test was called with #{args.to_sentence}"
+        end
+      end
+      """
+    When I run the code "TestMailer.test('recipient@test.com').deliver"
+    Then an email should have been sent
+    And the logger for the class "TestMailer" should be empty
+
+
+  Scenario: before_create callback skipped because included in "except" directive
+    Given the following mailer class with a before_create callback:
+      """
+      class TestMailer < ::ActionMailer::Base
+        before_create :log_args, except: :test
+
+        def self.logger
+          @logger ||= Array.new
+        end
+
+        def test(recipient)
+          mail(
+            to: recipient,
+            from: 'sender@test.com',
+            subject: 'Test Email'
+          )
+        end
+
+        private
+
+        def log_args
+          self.class.logger << "Test was called with #{args.to_sentence}"
         end
       end
       """

data/features/readme.md

@@ -0,0 +1,89 @@
+# ActionMailer Callbacks
+
+[![Build Status](https://secure.travis-ci.org/spaghetticode/actionmailer-callbacks.png)](http://travis-ci.org/spaghetticode/actionmailer-callbacks)
+
+This gem adds ```before_create``` and ```around_create``` to ActionMailer::Base
+to  make it work similarly to ActionController before/around filters and
+ActiveRecord::Base callbacks:
+
+```ruby
+  before_create :log_params, except: :test_email
+  around_create :benchmark,  only:   :test_email
+```
+
+```except``` and ```only``` options are optional and has same functionality as in
+ActionController.
+
+Callbacks functionality is implemented using the ActiveSupport::Callbacks module.
+
+
+## Requirements
+
+The master branch now works only with ActionMailer 3.x, if you need to add
+callbacks to older versions please refer to the 0.x release.
+
+
+## Installation
+
+Add the gem to the Gemfile:
+
+```ruby
+  gem 'actionmailer-callbacks'
+```
+
+And then run ```bundle```
+
+
+## Documentation
+
+You can find some more documentation on the workings of the gem on relish:
+https://www.relishapp.com/spaghetticode/actionmailer-callbacks/docs
+
+
+## Notes
+
+If you need something like before/after deliver callbacks ActionMailer 3.x comes
+ready for that: you can use an **observer** or an **instrumentation** for that.
+
+The **around_create** callback wraps the entire mail method execution. You can
+use them for rescuing from errors or for benchmarking, for example.
+
+The gem adds the ```args``` attribute accessor to the mail object in order to
+be able to access the arguments used for its initialization.
+
+## Example
+
+```ruby
+  class UserMailer < ActionMailer::Base
+    before_create :log_args
+    around_create :rescue_from_errors
+
+    def user_registration(user)
+      # this is a regular ActionMailer email method
+    end
+
+    private
+
+    def log_args
+      MailerLogger.info "[CREATE] #{args.inspect}"
+    end
+
+    def rescue_from_errors
+      begin
+        yield
+      rescue
+        puts 'An error occured!'
+      end
+    end
+  end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Add your feature tests to the rspec/cucumber test suite
+4. Commit your changes (`git commit -am 'Added some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/lib/actionmailer-callbacks.rb

@@ -1,9 +1,13 @@
 require 'action_mailer'
 
-lib_dir = File.expand_path('..', __FILE__)
-require File.join(lib_dir, 'actionmailer-callbacks/version')
-require File.join(lib_dir, 'actionmailer-callbacks/callback')
-require File.join(lib_dir, 'actionmailer-callbacks/callbackable')
-require File.join(lib_dir, 'actionmailer-callbacks/extensions')
+module ActionMailer
+  module Callbacks
+    autoload :Callbackable, 'actionmailer-callbacks/callbackable'
+    autoload :Extensions,   'actionmailer-callbacks/extensions'
+  end
+end
+
+require File.join(File.expand_path('..', __FILE__), 'actionmailer-callbacks/version')
+
 
 ActionMailer::Base.extend ActionMailer::Callbacks::Extensions

data/lib/actionmailer-callbacks/callbackable.rb

@@ -1,41 +1,20 @@
+require 'active_support/concern'
+require 'active_support/callbacks'
+
 module ActionMailer
   module Callbacks
     module Callbackable
       extend ActiveSupport::Concern
+      include ActiveSupport::Callbacks
 
-      module ClassMethods
-        def before_create_callbacks
-          @before_create_callbacks ||= Set.new
-        end
-
-        def add_before_create_callback(callback)
-          @before_create_callbacks << callback
-        end
-
-        def around_create_callback
-          @around_create_callback
-        end
-
-        def reset_callbacks
-          @before_create_callbacks = Set.new
-        end
+      included do
+        attr_internal_accessor :args
+        define_callbacks :initialize
       end
 
-      def initialize(method, *args)
-        result = nil
-        around_create_callback = self.class.around_create_callback
-        if around_create_callback and around_create_callback.run?(method)
-          send self.class.around_create_callback.name, *args do
-            self.class.before_create_callbacks.each do |callback|
-              send callback.name, *args if callback.run?(method)
-            end
-            result = super
-          end
-          result
-        else
-          self.class.before_create_callbacks.each do |callback|
-            send callback.name, *args if callback.run?(method)
-          end
+      def initialize(*args)
+        self.args = args
+        run_callbacks :initialize do
           super
         end
       end

data/lib/actionmailer-callbacks/extensions.rb

@@ -1,23 +1,32 @@
 module ActionMailer
   module Callbacks
     module Extensions
-      def before_create(*args)
-        include_callbackable
-        before_create_callbacks << Callback.new(*args)
+      %w[before around].each do |method|
+        define_method "#{method}_create" do |*args|                           # def before_create(*args)
+          include_callbackable                                                #   include_callbackable
+          opts = args.extract_options!                                        #   opts = args.extract_options!
+          args.each do |arg|                                                  #   args.each do |arg|
+            set_callback :initialize, method.to_sym, arg, _conditions(opts)   #     set_callback :initialize, :before, arg, _conditions(opts)
+          end                                                                 #   end
+        end                                                                   # end
       end
 
-      def around_create(*args)
-        include_callbackable
-        @around_create_callback = Callback.new(*args)
+      def _conditions(opts)
+        _condition(:if, opts[:only]) or _condition(:unless, opts[:except]) or {}
       end
 
       private
 
+      def _condition(type, actions)
+        if actions.present?
+          actions = Array.wrap(actions)
+          {type => Proc.new {|mail_obj| actions.include? mail_obj.args.first }}
+        end
+      end
+
       def include_callbackable
         callbackable = ActionMailer::Callbacks::Callbackable
-        unless ancestors.include?(callbackable)
-          include callbackable
-        end
+        include callbackable unless ancestors.include?(callbackable)
       end
     end
   end

data/lib/actionmailer-callbacks/version.rb

@@ -1,5 +1,5 @@
-module Actionmailer
+module ActionMailer
   module Callbacks
-    VERSION = '1.0.0'
+    VERSION = '1.1.0'
   end
 end

data/spec/lib/actionmailer-callbacks/callbackable_spec.rb

@@ -4,98 +4,18 @@ module ActionMailer
   module Callbacks
     describe Callbackable do
       let(:sample_class) {Class.new {include Callbackable}}
-      let(:callback) {double(name: :callback_method)}
 
-      subject {sample_class}
+      subject {sample_class.new}
 
-      before {subject.reset_callbacks}
+      describe 'args accessor' do
+        let(:args) {[:some, :args]}
 
-      context '#initialize' do
-        it 'checks for the around_create callback' do
-          sample_class.should_receive(:around_create_callback)
-          sample_class.new(:mailer_method)
-        end
-
-        it 'does not run the around_create callback if present but should not run' do
-          callback.stub(run?: false)
-          sample_class.stub(around_create_callback: callback)
-          sample_class.any_instance.should_not_receive(:callback_method)
-          sample_class.new(:mailer_method)
-        end
-
-        it 'runs the around_create callback if present and should run' do
-          callback.stub(run?: true)
-          sample_class.stub(around_create_callback: callback)
-          sample_class.any_instance.should_receive(:callback_method)
-          sample_class.new(:mailer_method)
-        end
-
-        it 'cycles on before_create_callbacks' do
-          sample_class.should_receive(:before_create_callbacks).and_return([])
-          sample_class.new(:mailer_method)
-        end
-
-        context 'when the callback should run' do
-          before {callback.stub run?: true}
-
-          it 'runs the callback included in the list' do
-            sample_class.stub(before_create_callbacks: [callback])
-            sample_class.any_instance.should_receive(:callback_method)
-            sample_class.new(:mailer_method)
-          end
-
-          it 'pass all the params to the callback' do
-            sample_class.stub(before_create_callbacks: [callback])
-            sample_class.any_instance.should_receive(:callback_method).with(:params)
-            sample_class.new(:mailer_method, :params)
-          end
-        end
+        before {subject.args = args}
 
-        context 'when the callback should not run' do
-          before {callback.stub run?: false}
-
-          it 'does not run the callback included in the list' do
-            sample_class.stub(before_create_callbacks: [callback])
-            sample_class.any_instance.should_not_receive(:callback_method)
-            sample_class.new(:mailer_method)
-          end
-        end
-      end
-
-      context 'class methods' do
-        describe 'before_create_callbacks' do
-          it 'responds to before_create_callbacks' do
-            subject.should respond_to(:before_create_callbacks)
-          end
-
-          it 'before_create_callbacks should be empty at start' do
-            subject.before_create_callbacks.should be_empty
-          end
-        end
-
-        describe 'add_before_create_callback' do
-          it 'responds to add_before_create_callback' do
-            subject.should respond_to(:add_before_create_callback)
-          end
-
-          it 'adds a callback to the before_create_callbacks list' do
-            subject.add_before_create_callback callback
-            subject.before_create_callbacks.should include(callback)
-          end
-
-          it 'does not add the same callback twice' do
-            2.times {subject.add_before_create_callback callback}
-            subject.before_create_callbacks.should have(1).callback
-          end
-        end
+        it {subject.args.should == args}
 
-        describe 'reset_callbacks' do
-          it 'empties the before_create_callbacks list' do
-            subject.add_before_create_callback callback
-            lambda do
-              subject.reset_callbacks
-            end.should change(subject, :before_create_callbacks).to(Set.new)
-          end
+        it 'is an internal accessor' do
+          subject.instance_eval {@_args}.should == args
         end
       end
     end

data/spec/lib/actionmailer-callbacks/extensions_spec.rb

@@ -15,20 +15,35 @@ module ActionMailer
         end
 
         describe 'before_create' do
-          it 'adds Callbackable to the ancestors' do
-            Callback.stub(:new)
+          it 'adds ActionMailer::Callbacks::Callbackable to the ancestors' do
             subject.before_create
             subject.ancestors.should include(ActionMailer::Callbacks::Callbackable)
           end
         end
 
         describe 'around_create' do
-          it 'adds Callbackable to the ancestors' do
-            Callback.stub(:new)
+          it 'adds ActionMailer::Callbacks::Callbackable to the ancestors' do
             subject.around_create
             subject.ancestors.should include(ActionMailer::Callbacks::Callbackable)
           end
         end
+
+        describe '_conditions' do
+          it 'returns empty hash when no "except" or "only" options are provided' do
+            opts = {}
+            subject._conditions(opts).should == {}
+          end
+
+          it 'returns a hash with :if key when "only" option is provided' do
+            opts = {:only => :index}
+            subject._conditions(opts).keys.should == [:if]
+          end
+
+          it 'returns a hash with :unless key when "except" option is provided' do
+            opts = {:except => :index}
+            subject._conditions(opts).keys.should == [:unless]
+          end
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmailer-callbacks
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-16 00:00:00.000000000 Z
+date: 2012-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionmailer
@@ -132,7 +132,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
-- .travis
+- .travis.yml
 - Gemfile
 - Guardfile
 - LICENSE
@@ -141,16 +141,15 @@ files:
 - actionmailer-callbacks.gemspec
 - features/around_create_callback.feature
 - features/before_create_callback.feature
+- features/readme.md
 - features/step_definitions/before_create_callback_steps.rb
 - features/support/env.rb
 - features/support/hooks.rb
 - features/support/world_extensions.rb
 - lib/actionmailer-callbacks.rb
-- lib/actionmailer-callbacks/callback.rb
 - lib/actionmailer-callbacks/callbackable.rb
 - lib/actionmailer-callbacks/extensions.rb
 - lib/actionmailer-callbacks/version.rb
-- spec/lib/actionmailer-callbacks/callback_spec.rb
 - spec/lib/actionmailer-callbacks/callbackable_spec.rb
 - spec/lib/actionmailer-callbacks/extensions_spec.rb
 - spec/spec_helper.rb
@@ -167,18 +166,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1517825137690287905
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1517825137690287905
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -188,12 +181,13 @@ summary: adds before_create, around_create callbacks to action mailer 3
 test_files:
 - features/around_create_callback.feature
 - features/before_create_callback.feature
+- features/readme.md
 - features/step_definitions/before_create_callback_steps.rb
 - features/support/env.rb
 - features/support/hooks.rb
 - features/support/world_extensions.rb
-- spec/lib/actionmailer-callbacks/callback_spec.rb
 - spec/lib/actionmailer-callbacks/callbackable_spec.rb
 - spec/lib/actionmailer-callbacks/extensions_spec.rb
 - spec/spec_helper.rb
 - spec/support/custom_matchers.rb
+has_rdoc: 

data/lib/actionmailer-callbacks/callback.rb

@@ -1,25 +0,0 @@
-module ActionMailer
-  module Callbacks
-    class Callback
-      attr_reader :name, :only, :except
-
-      def initialize(name, opts={})
-        @name   = name
-        @only   = Array.wrap(opts[:only])
-        @except = Array.wrap(opts[:except])
-      end
-
-      def run?(callback_method)
-        if only.include?(callback_method)
-          true
-        else
-          if except.include?(callback_method)
-            false
-          else
-            only.empty? ? true : false
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/actionmailer-callbacks/callback_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-module ActionMailer
-  module Callbacks
-    describe Callback do
-      context 'creating an instance' do
-        it 'requires name' do
-          expect {Callback.new}.to raise_error(ArgumentError)
-        end
-
-        context 'when name but no option is passed' do
-          subject {Callback.new(:name)}
-
-          it 'runs all callback methods' do
-            subject.should run(:any_method)
-          end
-        end
-
-        context 'when name and all options are passed' do
-          subject {Callback.new(:name, :only => :only_method, :except => [:except_method])}
-
-          it 'sets "name" attribute' do
-            subject.name.should == :name
-          end
-
-          it 'sets "only" reader' do
-            subject.only.should == [:only_method]
-          end
-
-          it 'sets "except" reader' do
-            subject.except.should == [:except_method]
-          end
-
-          it 'runs the methods included in the "only" list' do
-            subject.should run(:only_method)
-          end
-
-          it 'skips the methods not included in the "only" list' do
-            subject.should_not run(:other_method)
-          end
-
-          it 'skips the methods included in the "except" list' do
-            subject.should_not run(:except_method)
-          end
-        end
-      end
-    end
-  end
-end