after_do 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ef93b03d163368d4323b3b457a104fbcbf8dde4
-  data.tar.gz: c3efe779604f230849918900543f1a4a2d68d6f7
+  metadata.gz: 246d1c1ca42b79e8fedf494f8b9ef5620a88e998
+  data.tar.gz: 591190d78158bb4a97db932ac0481bad656cb35c
 SHA512:
-  metadata.gz: 384930d2ac61d25b48cd269db52679d8d0860ef0bfa5c13621c55ba26af30bb83b12aeb5f2ad0f58065d9c1d71dada4d5a784d876c09374e3ed6c17de75f8ec1
-  data.tar.gz: 2bf8dd100317b5a6ec541ddd514288eae869b4b0930d3fe6a28ef08bda302837e8c84e32f1722fd1021edec6c100de846a46cd4a53213d128e900a7fdf2c90ee
+  metadata.gz: b3b639f1aa8bc684b30b8c1b16026bf2406c98872563ff10aadad02177f47715c8f9eec270409fdbbd9213087323cebd5b38b566308cb12e5b02c9fbf0585321
+  data.tar.gz: b05353aee06b2b7ad93347ad7fdf5284b46529b984ddc58411a10b374437a2e91907d91cd925cda6aba614671bbdaf55fbb42e20e796f26320d4e22a335749cc

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0-p195
+ruby-2.0.0-p247

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
+  - rbx-19mode
+  - jruby-19mode
   - 1.9.3
   - 2.0
-  - jruby-19mode
-  - rbx-19mode
-script: bundle exec rspec spec
+script: bundle exec rspec spec

data/Gemfile

@@ -2,3 +2,10 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in after_do.gemspec
 gemspec
+
+gem 'bundler', '~> 1.3'
+gem 'rake'
+gem 'rspec'
+gem 'guard-rspec'
+gem 'simplecov'
+gem 'coveralls'

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -1,10 +1,15 @@
-# AfterDo [![Build Status](https://travis-ci.org/PragTob/after_do.png?branch=master)](https://travis-ci.org/PragTob/after_do)[![Code Climate](https://codeclimate.com/github/PragTob/after_do.png)](https://codeclimate.com/github/PragTob/after_do)
+# AfterDo [![Gem Version](https://badge.fury.io/rb/after_do.png)](http://badge.fury.io/rb/after_do)[![Build Status](https://travis-ci.org/PragTob/after_do.png?branch=master)](https://travis-ci.org/PragTob/after_do)[![Code Climate](https://codeclimate.com/github/PragTob/after_do.png)](https://codeclimate.com/github/PragTob/after_do)[![Coverage Status](https://coveralls.io/repos/PragTob/after_do/badge.png)](https://coveralls.io/r/PragTob/after_do)
 
-AfterDo is simple gem, that allows you to execute a specified block after specified method of a class are called. If the class extends `AfterDo` you can simply do this by `MyClass.after :some_method do puts 'whatever you want?' end`
+AfterDo is simple gem, that allows you to execute a specified block after specified method of a class are called. If the class extends `AfterDo` you can simply do this by
 
-This shall not be done to to alter behavior or something but rather to fight cross-cutting concerns such as logging. E.g. with logging you litter all your code wit logging statements - that concern is spread over many files. With AfterDo you could put all the logging in one file.
+```
+MyClass.after :some_method do whatever_you_want end
+```
 
-AfterDo has no external runtime dependencies and the code is just a bit more than 60 lines (blank lines included).
+Why would you want to do this? Well to fight cross-cutting concerns such as logging. E.g. there are concerns in an applications that apply to multiple objects (e.g. they cross-cut). A popular example is logging - you might want to log multiple actions but logging is not the primary concern of the class in question. With logging you litter all your code with logging statements - that concern is spread over many files. With AfterDo you could put all the logging in one file. Other use cases include gathering business statistics or redrawing timing of elements. Personally I extracted this gem from a project where I wanted to decouple my domain objects from the way they are saved (for fun and profit!).
+This should generally not be done to alter behavior of the class and its instances - this makes programs more confusing rather than easier to understand.
+
+AfterDo has no external runtime dependencies and the code is around 120 lines of code (blank lines included) with lots of small methods. So simplecov reports there are not even 70 relevant lines.
 
 ## Installation
 
@@ -22,17 +27,24 @@ Or install it yourself as:
 
 ## Usage
 
-With AfterDo you can do simple things like putting something out everything a method is called as in this example:
+This section is dedicated to show of the general usage and effects of AfterDo. You can also check out the samples directory for some samples or the specs in the spec folder.
+
+### General usage
+
+In order to use AfterDo the class/module you want to use it with first has to extend the `AfterDo` module. You can do this right in the class definition or afterwards like this: `MyClass.extend AfterDo`.
+With this setup you can add a callback to `method` like this:
+
+```ruby
+MyClass.after :method do magic end
+```
+
+With AfterDo you can do simple things like printing something out every time a method is called as in this example:
 
 ```ruby
 class Dog
   def bark
     puts 'Woooof'
   end
-
-  def eat
-    puts 'yummie!'
-  end
 end
 
 Dog.extend AfterDo
@@ -42,26 +54,232 @@ dog = Dog.new
 dog2 = Dog.new
 
 dog.bark
-dog.eat
 dog2.bark
 
 # Output is:
 # Woooof
 # I just heard a dog bark!
-# yummie!
 # Woooof
 # I just heard a dog bark!
 
 ```
 
+### How does it work?
+
+When you attach a callback to a method with AfterDo what it basically does is it creates a copy of that method and then redefines the method to basically look like this (pseudo code):
+
+```ruby
+execute_before_callbacks
+return_value = original_method
+execute_after_callbacks
+return_value
+```
+
+To do this some helper methods are defined in the AfterDo module. As classes have to extend the AfterDo module all the methods that you are not supposed to call yourself are prefixed with `_after_do_` to minimize the risk of method name clashes. The only not prefixed method are `after`, `before` and `remove_all_callbacks`.
+
+### Getting a hold of the method arguments and the object
+
+With AfterDo both the arguments to the method you are attaching the callback to and the object for which the callback is executed are passed into the callback block.
+
+So if you have a method that takes two arguments you can get those like this:
+
+```ruby
+MyClass.after :two_arg_method do |argument_one, argument_2| something end
+```
+
+The object itself is passed in as the last block argument, so if you just care about the object you can do:
+
+```ruby
+MyClass.after :two_arg_method do |*, obj| fancy_stuff(obj) something end
+```
+
+Of course you can get a hold of the method arguments and the object:
+
+```ruby
+MyClass.after :two_arg_method do |arg1, arg2, obj| something(arg1, arg2, obj) end
+```
+
+If you do not want to get a hold of the method arguments or the object, then you can just don't care about the block parameters :-)
+
+Here is an example showcasing all of these:
+
+```ruby
+class Example
+  def zero
+    # ...
+  end
+
+  def two(a, b)
+    # ...
+  end
+
+  def value
+    'some value'
+  end
+end
+
+Example.extend AfterDo
+
+Example.after :zero do puts 'Hello!' end
+Example.after :zero do |obj| puts obj.value end
+Example.after :two do |first, second| puts first + ' ' + second end
+Example.after :two do |a, b, obj| puts a + ' ' + b + ' ' + obj.value end
+Example.after :two do |*, obj| puts 'just ' +  obj.value end
+
+e = Example.new
+e.zero
+e.two 'one', 'two'
+# prints:
+# Hello!
+# some value
+# one two
+# one two some value
+# just some value
+```
+
+### Attaching a callback to multiple methods
+
+In AfterDo you can attach a callback to multiple methods by just listing them:
+
+```ruby
+SomeClass.after :one_method, :another_method do something end
+```
+
+Or you could pass in an Array of method names:
+
+```ruby
+SomeClass.after [:one_method, :another_method] do something end
+```
+
+So for example if you have an activity and want the activity to be saved every time you change it, but you don't want to mix that persistence concern with what the activity actually does you could do something like this:
+
+```ruby
+persistor  = FilePersistor.new
+Activity.extend AfterDo
+Activity.after :start, :pause, :finish, :resurrect,
+             :do_today, :do_another_day do |activity|
+  persistor.save activity
+end
+```
+
+Doesn't that seem a lot drier then calling some save method manually after each of those in addition to separating the concerns?
+
+### Attaching multiple callbacks to the same method
+
+A method can have as many callbacks as a Ruby Array can handle (although I do not recommend you to have many callbacks around). So this works perfectly fine:
+
+```ruby
+MyClass.after :method do something end
+MyClass.after :method do another_thing end
+```
+
+The callbacks are executed in the order in which they were added.
+
+### Working with inheritance
+
+AfterDo also works with inheritance. E.g. if you attach a callback to a method in a super class and that method is called in a sub class the callback is still executed.
+
+See this sample:
+
+```ruby
+class A
+  def a
+    # ...
+  end
+end
+
+class B < A
+end
+
+A.extend AfterDo
+A.after :a do puts 'a was called' end
+
+b = B.new
+b.a #prints out: a was called
+```
+
+### Removing callbacks
+
+You can remove all callbacks you added to a class by doing:
+
+```ruby
+MyClass.remove_all_callbacks
+```
+
+### Errors
+
+There are some custom errors that AfterDo throws. When you try to add a callback to a method which that class does not understand it will throw `AfterDo::NonExistingMethodError`.
+
+When an error occurs during one of the callbacks that are attached to a method it will throw `AfterDo::CallbackError` with information about the original error and where the block/callback causing this error was defined to help pinpoint the error.
+
+
 ## Is there a before method?
 
-No not yet, I didn't have a use case for it yet. If you have one please let me know, it is relatively easy to add.
+Yes. It works just like the `after` method, but the callbacks are executed before the original method is called. You can also mix and match before and after calls.
+
+Before for me is a far less common use case, that's why it was only added later (in the 0.2 release).
+
+Here is a small sample:
+
+```ruby
+require 'after_do'
+
+class MyClass
+  attr_accessor :value
+end
+
+MyClass.extend AfterDo
+MyClass.after :value= do |*, obj| puts 'after: ' + obj.value.to_s end
+MyClass.before :value= do |*, obj| puts 'before: ' + obj.value.to_s end
+
+m = MyClass.new
+m.value = 'Hello'
+m.value = 'new value'
+
+# Output is:
+# before:
+# after: Hello
+# before: Hello
+# after: new value
+```
+
+### Method granularity
+
+AfterDo works on the granularity of methods. That means that you can only attach callbacks to methods. This is no problem however, since if it's your code you can always define new methods. E.g. you want to attach callbacks to the end of some operation that happens in the middle of a method just define a new method for that piece of code.
+
+I sometimes do this for evaluating the block, as I want to do something when that block finished evaluating so I define a method `eval_block` wherein I just evaluate the block.
+
+## Is this a good idea?
+
+Always depends on what you are doing with it. As many things out there it has its use cases but can easily be misused.
+
+### Advantages
+
+- Get cross cutting concerns packed together in one file - don't have them scattered all over your code base obfuscating what the real responsibility of that class is
+- Don't repeat yourself, define what is happening when in one file
+- I feel like it helps the Single Responsibility principle, as it enables classes to focus on what their main responsibility is and not deal with other stuff. I initially wrote this gem when I wanted to decouple an object of my domain from the way it is saved.
+
+### Drawbacks
+
+- You lose clarity. With callbacks after a method it is not immediately visible what happens when a method is called as some behavior might be defined elsewhere.
+- You could use this to modify the behaviour of classes everywhere. Don't. Use it for what it is meant to be used for - a concern that is not the primary concern of the class you are adding the callback to but that class is still involved with.
+
+A use case I feel this is particularly made for is redrawing. That's what we use it for over at [shoes4](https://github.com/shoes/shoes4). E.g. we have multiple objects and different actions on these objects may trigger a redraw (such changing the position of a circle). This concern could be littered all over the code base. Or nicely packed into one file where you don't repeat yourself for similar redrawing scenarios and you see all the redraws at one glance. Furthermore it makes it easier to do things like "Just do one redraw every 1/30s" (not yet implemented).
+
+## Does it work with Ruby interpreter X?
+
+Thanks to the awesome [travis CI](https://travis-ci.org/) the specs are run with MRI 1.9.3, 2.0, the latest jruby and rubinius releases in 1.9 mode. So in short, this should work with all of them and is aimed at doing so :-)
 
 ## Contributing
 
+Contributions are very welcome. Whether it's an issue or even a pull request. For pull requests the you can use the following flow:
+
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+I'd also really appreciate spec only pull requests or bug reports with a failing spec/minimal example as this makes fixing it a lot easier =)
+
+Thanks in advance for all contributions of any kind!

data/after_do.gemspec

@@ -16,10 +16,4 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files`.split($/)
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "coveralls"
 end

data/lib/after_do/version.rb

@@ -1,3 +1,3 @@
 module AfterDo
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/after_do.rb

@@ -1,62 +1,120 @@
 module AfterDo
   ALIAS_PREFIX = '__after_do_orig_'
 
-  def _after_do_callbacks
-    @_after_do_callbacks
+  def self.extended(klazz)
+    klazz.send(:include, AfterDo::Instance)
+    klazz.send(:extend, AfterDo::Class)
   end
 
-  def after(*methods, &block)
-    @_after_do_callbacks ||= Hash.new([])
-    methods.flatten! #in case someone used an Array
-    if methods.empty?
-      raise ArgumentError, 'after takes at least one method name!'
+  class NonExistingMethodError < StandardError ; end
+  class CallbackError < StandardError ; end
+
+  module Class
+
+    def _after_do_callbacks
+      @_after_do_callbacks || _after_do_basic_hash
+    end
+
+    def after(*methods, &block)
+      _after_do_define_callback(:after, methods, block)
+    end
+
+    def before(*methods, &block)
+      _after_do_define_callback(:before, methods, block)
+    end
+
+    def remove_all_callbacks
+      @_after_do_callbacks = _after_do_basic_hash if @_after_do_callbacks
+    end
+
+    private
+    def _after_do_define_callback(type, methods, block)
+      @_after_do_callbacks ||= _after_do_basic_hash
+      methods.flatten! #in case someone used an Array
+      _after_do_raise_no_method_specified(type) if methods.empty?
+      methods.each do |method|
+        _after_do_add_callback_to_method(type, method, block)
+      end
     end
-    methods.each do |method|
-      if _after_do_method_already_renamed?(method)
+
+    def _after_do_raise_no_method_specified(type)
+      raise ArgumentError, "#{type} takes at least one method name!"
+    end
+
+    def _after_do_basic_hash
+      {before: {}, after: {}}
+    end
+
+    def _after_do_add_callback_to_method(type, method, block)
+      unless _after_do_method_already_renamed?(method)
         _after_do_make_after_do_version_of_method(method)
       end
-      @_after_do_callbacks[method] << block
+      @_after_do_callbacks[type][method] << block
     end
-  end
 
-  def remove_all_callbacks
-    if @_after_do_callbacks
-      @_after_do_callbacks.keys.each do |key| @_after_do_callbacks[key] = [] end
+    def _after_do_make_after_do_version_of_method(method)
+      _after_do_raise_no_method_error(method) unless method_defined? method
+      @_after_do_callbacks[:before][method] = []
+      @_after_do_callbacks[:after][method] = []
+      alias_name = _after_do_aliased_name method
+      _after_do_rename_old_method(method, alias_name)
+      _after_do_redefine_method_with_callback(method, alias_name)
     end
-  end
 
-  private
-  def _after_do_make_after_do_version_of_method(method)
-    @_after_do_callbacks[method] = []
-    alias_name = _after_do_aliased_name method
-    _after_do_rename_old_method(method, alias_name)
-    _after_do_redefine_method_with_callback(method, alias_name)
-  end
+    def _after_do_raise_no_method_error(method)
+      raise NonExistingMethodError, "There is no method #{method} on #{self} to attach a block to with AfterDo"
+    end
 
-  def _after_do_aliased_name(symbol)
-    (ALIAS_PREFIX + symbol.to_s).to_sym
-  end
+    def _after_do_aliased_name(symbol)
+      (ALIAS_PREFIX + symbol.to_s).to_sym
+    end
 
-  def _after_do_rename_old_method(old_name, new_name)
-    class_eval do
-      alias_method new_name, old_name
-      private new_name
+    def _after_do_rename_old_method(old_name, new_name)
+      class_eval do
+        alias_method new_name, old_name
+        private new_name
+      end
     end
-  end
 
-  def _after_do_redefine_method_with_callback(method, alias_name)
-    class_eval do
-      define_method method do |*args|
-        return_value = send(alias_name, *args)
-        self.class._after_do_callbacks[method].each do |block|
-          block.call *args, self
+    def _after_do_redefine_method_with_callback(method, alias_name)
+      class_eval do
+        define_method method do |*args|
+          _after_do_execute_callbacks :before, method, *args
+          return_value = send(alias_name, *args)
+          _after_do_execute_callbacks :after, method, *args
+          return_value
         end
-        return_value
       end
     end
+
+    def _after_do_method_already_renamed?(method)
+      private_method_defined? _after_do_aliased_name(method)
+    end
   end
 
-  def _after_do_method_already_renamed?(method)
-    !private_method_defined? _after_do_aliased_name(method)
+  module Instance
+    def _after_do_execute_callbacks(type, method, *args)
+      callback_classes = self.class.ancestors.select do |klazz|
+        _after_do_has_callback_for?(klazz, type, method)
+      end
+      callback_classes.each do |klazz|
+        klazz._after_do_callbacks[type][method].each do |block|
+          _after_do_execute_callback(block, method, *args)
+        end
+      end
+    end
+
+    def _after_do_has_callback_for?(klazz, type, method)
+      klazz.respond_to?(:_after_do_callbacks) &&
+        klazz._after_do_callbacks[type][method]
+    end
+
+    def _after_do_execute_callback(block, method, *args)
+      begin
+        block.call *args, self
+      rescue Exception => error
+        raise CallbackError, "A callback block for method #{method} on the instance #{self} with the following arguments: #{args.join(', ')} defined in the file #{block.source_location[0]} in line #{block.source_location[1]} resulted in the following error: #{error.class}: #{error.message} and this backtrace:\n #{error.backtrace.join("\n")}"
+      end
+    end
   end
 end

data/samples/before.rb

@@ -0,0 +1,19 @@
+require 'after_do'
+
+class MyClass
+  attr_accessor :value
+end
+
+MyClass.extend AfterDo
+MyClass.after :value= do |*, obj| puts 'after: ' + obj.value.to_s end
+MyClass.before :value= do |*, obj| puts 'before: ' + obj.value.to_s end
+
+m = MyClass.new
+m.value = 'Hello'
+m.value = 'new value'
+
+# Output is:
+# before:
+# after: Hello
+# before: Hello
+# after: new value

data/samples/dog.rb

@@ -1,13 +1,9 @@
-require File.expand_path('../../lib/after_do', __FILE__)
+require 'after_do'
 
 class Dog
   def bark
     puts 'Woooof'
   end
-
-  def eat
-    puts 'yummie!'
-  end
 end
 
 Dog.extend AfterDo
@@ -17,5 +13,4 @@ dog = Dog.new
 dog2 = Dog.new
 
 dog.bark
-dog.eat
-dog2.bark
+dog2.bark

data/samples/error_in_callback.rb

@@ -0,0 +1,12 @@
+require 'after_do'
+
+class A
+  def work
+    # ..
+  end
+end
+
+A.extend AfterDo
+A.after :work do 1/0 end
+
+A.new.work

data/samples/getting_a_hold.rb

@@ -0,0 +1,33 @@
+require 'after_do'
+
+class Example
+  def zero
+    # ...
+  end
+
+  def two(a, b)
+    # ...
+  end
+
+  def value
+    'some value'
+  end
+end
+
+Example.extend AfterDo
+
+Example.after :zero do puts 'Hello!' end
+Example.after :zero do |obj| puts obj.value end
+Example.after :two do |first, second| puts first + ' ' + second end
+Example.after :two do |a, b, obj| puts a + ' ' + b + ' ' + obj.value end
+Example.after :two do |*, obj| puts 'just ' +  obj.value end
+
+e = Example.new
+e.zero
+e.two 'one', 'two'
+# prints:
+# Hello!
+# some value
+# one two
+# one two some value
+# just some value

data/samples/inheritance.rb

@@ -0,0 +1,16 @@
+require 'after_do'
+
+class A
+  def a
+    # ...
+  end
+end
+
+class B < A
+end
+
+A.extend AfterDo
+A.after :a do puts 'a was called' end
+
+b = B.new
+b.a #prints out: a was called

data/samples/within_class.rb

@@ -0,0 +1,29 @@
+require 'after_do'
+
+class Team
+  extend AfterDo
+  
+  def add_member(member)
+    # ...
+  end
+  
+  def remove_member(member)
+    # ..
+  end
+  
+  def change_name(new_name)
+    # ..
+  end
+  
+  def save
+   # ..
+   puts 'saving...'
+  end
+  
+  after :add_member, :remove_member, :change_name do |*args, team| team.save end
+end
+
+team = Team.new
+team.add_member 'Maren'
+team.change_name 'Ruby Cherries'
+team.remove_member 'Guilia'

data/spec/after_do_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe AfterDo do
+
   let(:dummy_instance) {@dummy_class.new}
   let(:mockie) {double}
 
@@ -25,119 +26,228 @@ describe AfterDo do
     end
   end
 
+  shared_examples_for 'calling callbacks' do |callback_adder|
+    it 'responds to before/after' do
+      @dummy_class.should respond_to callback_adder
+    end
 
-  it 'responds to after' do
-    @dummy_class.should respond_to :after
-  end
+    it 'calls a method on the injected mockie' do
+      @dummy_class.send callback_adder, :zero do mockie.call_method end
+      mockie.should_receive :call_method
+      dummy_instance.zero
+    end
 
-  it 'calls a method on the injected mockie' do
-    mockie.should_receive :call_method
-    @dummy_class.after :zero do mockie.call_method end
-    dummy_instance.zero
-  end
+    it 'does not change the return value' do
+      before_return_value = dummy_instance.zero
+      @dummy_class.send callback_adder, :zero do 42 end
+      after_return_value = dummy_instance.zero
+      after_return_value.should eq before_return_value
+    end
 
-  it 'does not change the return value' do
-    before = dummy_instance.zero
-    @dummy_class.after :zero do 42 end
-    after = dummy_instance.zero
-    after.should eq before
-  end
+    it 'marks the copied method as private' do
+      @dummy_class.send callback_adder,  :zero do end
+      copied_method_name = (AfterDo::ALIAS_PREFIX + 'zero').to_sym
+      dummy_instance.respond_to?(copied_method_name).should be_false
+    end
 
-  it 'marks the copied method as private' do
-    @dummy_class.after :zero do end
-    copied_method_name = (AfterDo::ALIAS_PREFIX + 'zero').to_sym
-    dummy_instance.respond_to?(copied_method_name).should be_false
-  end
+    it 'can add multiple call backs' do
+      mockie.should_receive :call_method
+      mock2 = double
+      mock2.should_receive :call_another_method
+      mock3 = double
+      mock3.should_receive :bla
+      @dummy_class.send callback_adder, :zero do mockie.call_method end
+      @dummy_class.send callback_adder, :zero do mock2.call_another_method end
+      @dummy_class.send callback_adder, :zero do mock3.bla end
+      dummy_instance.zero
+    end
 
-  it 'can add multiple call backs' do
-    mockie.should_receive :call_method
-    mock2 = double
-    mock2.should_receive :call_another_method
-    mock3 = double
-    mock3.should_receive :bla
-    @dummy_class.after :zero do mockie.call_method end
-    @dummy_class.after :zero do mock2.call_another_method end
-    @dummy_class.after :zero do mock3.bla end
-    dummy_instance.zero
-  end
+    it 'can remove all callbacks' do
+      mockie.should_not_receive :call_method
+      @dummy_class.send callback_adder, :zero do mockie.call_method end
+      @dummy_class.remove_all_callbacks
+      dummy_instance.zero
+    end
 
-  it 'can remove all callbacks' do
-    mockie.should_not_receive :call_method
-    @dummy_class.after :zero do mockie.call_method end
-    @dummy_class.remove_all_callbacks
-    dummy_instance.zero
-  end
+    describe 'errors' do
+      it 'throws an error when you try to add a hook to a non existing method' do
+        expect do
+          @dummy_class.send callback_adder,  :non_existing_method do ; end
+        end.to raise_error(AfterDo::NonExistingMethodError)
+      end
 
-  describe 'with parameters' do
+      describe 'errors in callbacks' do
 
-    before :each do
-      mockie.should_receive :call_method
-    end
+        def expect_call_back_error(matcher = nil)
+          expect do
+            dummy_instance.zero
+          end.to raise_error AfterDo::CallbackError, matcher
+        end
+
+        before :each do
+          @dummy_class.send callback_adder,  :zero do raise StandardError, 'silly message' end
+        end
+
+        it 'raises a CallbackError' do
+          expect_call_back_error
+        end
+
+        it 'mentions the error raised' do
+          expect_call_back_error /StandardError/
+        end
 
-    it 'can handle methods with a parameter' do
-      @dummy_class.after :one do mockie.call_method end
-      dummy_instance.one 5
+        it 'mentions the method called' do
+          expect_call_back_error /zero/
+        end
+
+        it 'mentions the file the error was raised in' do
+          expect_call_back_error Regexp.new __FILE__
+        end
+
+        it 'mentions the original error message' do
+          expect_call_back_error /silly message/
+        end
+      end
     end
 
-    it 'can handle methods with 2 parameters' do
-      @dummy_class.after :two do mockie.call_method end
-      dummy_instance.two 5, 8
+    describe 'with parameters' do
+
+      before :each do
+        mockie.should_receive :call_method
+      end
+
+      it 'can handle methods with a parameter' do
+        @dummy_class.send callback_adder,  :one do mockie.call_method end
+        dummy_instance.one 5
+      end
+
+      it 'can handle methods with 2 parameters' do
+        @dummy_class.send callback_adder,  :two do mockie.call_method end
+        dummy_instance.two 5, 8
+      end
     end
-  end
 
-  describe 'with parameters for the given block' do
-    it 'can handle one block parameter' do
-      mockie.should_receive(:call_method).with(5)
-      @dummy_class.after :one do |i| mockie.call_method i end
-      dummy_instance.one 5
+    describe 'with parameters for the given block' do
+      it 'can handle one block parameter' do
+        mockie.should_receive(:call_method).with(5)
+        @dummy_class.send callback_adder,  :one do |i| mockie.call_method i end
+        dummy_instance.one 5
+      end
+
+      it 'can handle two block parameters' do
+        mockie.should_receive(:call_method).with(5, 8)
+        @dummy_class.send callback_adder,  :two do |i, j| mockie.call_method i, j end
+        dummy_instance.two 5, 8
+      end
     end
 
-    it 'can handle two block parameters' do
-      mockie.should_receive(:call_method).with(5, 8)
-      @dummy_class.after :two do |i, j| mockie.call_method i, j end
-      dummy_instance.two 5, 8
+    describe 'multiple methods' do
+      def call_all_3_methods
+        dummy_instance.zero
+        dummy_instance.one 4
+        dummy_instance.two 4, 5
+      end
+
+      it 'can take multiple method names as arguments' do
+        mockie.should_receive(:call_method).exactly(3).times
+        @dummy_class.send callback_adder,  :zero, :one, :two do mockie.call_method end
+        call_all_3_methods
+      end
+
+      it 'can get the methods as an Array' do
+        mockie.should_receive(:call_method).exactly(3).times
+        @dummy_class.send callback_adder,  [:zero, :one, :two] do mockie.call_method end
+        call_all_3_methods
+      end
+
+      it 'raises an error when no method is specified' do
+        expect do
+          @dummy_class.send callback_adder do mockie.call_method end
+        end.to raise_error ArgumentError
+      end
     end
-  end
 
-  describe 'multiple methods' do
-    def call_all_3_methods
-      dummy_instance.zero
-      dummy_instance.one 4
-      dummy_instance.two 4, 5
+    describe 'it can get a hold of self, if needbe' do
+      it 'works for a method without arguments' do
+        mockie.should_receive(:call_method).with(dummy_instance)
+        @dummy_class.send callback_adder,  :zero do |object| mockie.call_method(object) end
+        dummy_instance.zero
+      end
+
+      it 'works for a method with 2 arguments' do
+        mockie.should_receive(:call_method).with(1, 2, dummy_instance)
+        @dummy_class.send callback_adder,  :two do |first, second, object|
+          mockie.call_method(first, second, object)
+        end
+        dummy_instance.two 1, 2
+      end
     end
 
-    it 'can take multiple method names as arguments' do
-      mockie.should_receive(:call_method).exactly(3).times
-      @dummy_class.after :zero, :one, :two do mockie.call_method end
-      call_all_3_methods
+    describe 'inheritance' do
+      let(:inherited_instance) {@inherited_class.new}
+
+      before :each do
+        define_inherited_class
+      end
+
+      def define_inherited_class
+        @inherited_class = Class.new @dummy_class
+      end
+
+      it 'class knows about the after/before method' do
+        @inherited_class.should respond_to callback_adder
+      end
+
+      describe 'callback on parent class' do
+        before :each do
+          @dummy_class.send callback_adder, :zero do mockie.call end
+        end
+
+        it 'works when we have a callback on the parent class' do
+          mockie.should_receive :call
+          inherited_instance.zero
+        end
+
+        it 'remove_callbacks does not remove the callbacks on parent class' do
+          mockie.should_receive :call
+          @inherited_class.remove_all_callbacks
+          inherited_instance.zero
+        end
+
+        it 'remove_callbacks on the parent does remove the callbacks' do
+          mockie.should_not_receive :call
+          @dummy_class.remove_all_callbacks
+          inherited_instance.zero
+        end
+      end
     end
+  end
+
+  it_behaves_like 'calling callbacks', :after
+  it_behaves_like 'calling callbacks', :before
 
-    it 'can get the methods as an Array' do
-      mockie.should_receive(:call_method).exactly(3).times
-      @dummy_class.after [:zero, :one, :two] do mockie.call_method end
-      call_all_3_methods
+  describe 'before and after behaviour' do
+    let(:callback){double 'callback', before_call: nil, after_call: nil}
+
+    before :each do
+      @dummy_class.before :zero do callback.before_call end
+      @dummy_class.after :zero do callback.after_call end
     end
 
-    it 'raises an error when no method is specified' do
-      expect do
-        @dummy_class.after do mockie.call_method end
-      end.to raise_error ArgumentError
+    it 'calls the before callback' do
+      callback.should_receive :before_call
+      dummy_instance.zero
     end
-  end
 
-  describe 'it can get a hold of self, if needbe' do
-    it 'works for a method without arguments' do
-      mockie.should_receive(:call_method).with(dummy_instance)
-      @dummy_class.after :zero do |object| mockie.call_method(object) end
+    it 'calls the after callback' do
+      callback.should_receive :after_call
       dummy_instance.zero
     end
 
-    it 'works for a method with 2 arguments' do
-      mockie.should_receive(:call_method).with(1, 2, dummy_instance)
-      @dummy_class.after :two do |first, second, object|
-        mockie.call_method(first, second, object)
-      end
-      dummy_instance.two 1, 2
+    it 'receives the calls in the right order' do
+      callback.should_receive(:before_call).ordered
+      callback.should_receive(:after_call).ordered
+      dummy_instance.zero
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,5 +4,9 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   Coveralls::SimpleCov::Formatter,
   SimpleCov::Formatter::HTMLFormatter
 ]
-SimpleCov.start
-require 'after_do'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require 'after_do'

metadata

@@ -1,85 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: after_do
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tobias Pfeiffer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2013-11-15 00:00:00.000000000 Z
+dependencies: []
 description: after_do is a gem that let's you execute a block of your choice after
   a specific method was called on a class.
 email:
@@ -93,13 +23,19 @@ files:
 - .ruby-version
 - .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - after_do.gemspec
 - lib/after_do.rb
 - lib/after_do/version.rb
+- samples/before.rb
 - samples/dog.rb
+- samples/error_in_callback.rb
+- samples/getting_a_hold.rb
+- samples/inheritance.rb
+- samples/within_class.rb
 - spec/after_do_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/PragTob/after_do
@@ -122,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: after_do allows you to do simple after hooks on methods