after_do 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d5697c2f0c8130887073ed0072678789e8602cc
-  data.tar.gz: 40ad3b18353a8233045639effb09e95df96ab3b7
+  metadata.gz: ef369cfcfc9f7d0df1898cb7a19063c54d8197ab
+  data.tar.gz: 5e9cb593b171bdb4847f92aaa6ab8bf12baa3186
 SHA512:
-  metadata.gz: 404f4d82231b298a86d8e6699054dd0ca799a1b0e8ad85690ba2d308bb3b2d6b44564862da3440306f4ddde4ccb5e4a86f7e468a4a61cd22217c8a0ce99ac81e
-  data.tar.gz: e6e641a679300989f91a1185d546c2dca3ac2b3d31dbdbf5b6df7ed01bb8f3a690c99bf155bc104ef0f671bf3c25fca3dcb2bf6e769a320c066cc906a6f59020
+  metadata.gz: 8d27b6cd8f09cad52b0b721c247c598c18178631133b92f730dcaa8b497acbf78a49d5130f9c48cc79528557a4ee0fb3b222b1783461ba26d030d43bff2b2088
+  data.tar.gz: 7af1a95ded2526a59b80d8bf7059df8906844d64ec9755c831170e5dee3e86e62040d08b4586e01381678449563d1a0579807fce67c722fcd81919d3a479ed3f

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0-p353
+ruby-2.1.1

data/README.md

@@ -1,6 +1,6 @@
 # after_do [![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)
 
-after_do is simple gem, that helps you fight cross-cutting concerns with an approach similar to Aspect Oriented Programming (AOP). after_do allows you to execute blocks (callbacks) after/before specific methods of a class or a module are called.
+after_do is a simple gem, that helps you fight cross-cutting concerns with an approach similar to Aspect Oriented Programming (AOP). after_do allows you to execute blocks (callbacks) after/before specific methods of a class or a module are called.
 
 If the class extends `AfterDo` you can simply do this by
 
@@ -10,14 +10,15 @@ MyClass.after :some_method do whatever_you_want end
 
 Some facts about after_do:
 
-* no external runtime dependencies
+* no runtime dependencies
 * small code base: code is around 120 lines of code with blank lines, comments and everything - simplecov reports less than 60 relevant lines of code
 * simple DSL
 * no monkey patching
 
 ## Why would you want to do this?
 Well to fight cross-cutting concerns. These 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 of different classes 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 and adds unnecessary noise to them. With after_do you could put all the logging in one file. Other use cases include gathering business statistics or redrawing timing of elements.
+A popular example is logging - you might want to log multiple actions of different classes 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 and adds unnecessary noise to them.
+With after_do you could put all the logging in one file. Other use cases include gathering business statistics or redrawing timing of elements.
 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.
 
 The idea for this is inspired by Aspect Oriented Programming - e.g. do something when specific methods are executed. However I doubt that this formally fulfills the lingo (join points, aspects, advice...)
@@ -35,10 +36,14 @@ And then execute:
 Or install it yourself as:
 
     $ gem install after_do
+    
+And then you have to require the gem before you can use it:
+
+    require 'after_do'
 
 ## Usage
 
-This section is dedicated to show of the general usage and effects of after_do. You can also check out the samples directory for some samples or the specs in the spec folder.
+This section is dedicated to show the general usage and effects of after_do. You can also check out the [samples directory](https://github.com/PragTob/after_do/tree/master/samples) or the [specs](https://github.com/PragTob/after_do/blob/master/spec/after_do_spec.rb) in the spec folder.
 
 ### General usage
 
@@ -72,22 +77,8 @@ dog2.bark
 # I just heard a dog bark!
 # Woooof
 # I just heard a dog bark!
-
-```
-
-### How does it work?
-
-When you attach a callback to a method with after_do 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 after_do 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.
@@ -175,9 +166,47 @@ b = B.new
 b.a #prints out: a was called
 ```
 
+### Working with modules
+
+after_do works with modules just like it works with classes from version 0.3.0 onwards. E.g. you can just do:
+
+```ruby
+class MyClass
+  include MyModule
+  # ....
+end 
+
+MyModule.extend AfterDo
+MyModule.after :some_method do cool_stuff end
+
+MyClass.new.some_method # triggers callback
+```
+
+### Working with module/class/singleton methods
+
+after_do also works with module/class/singleton methods whatever you want to call them, e.g. with `MyModule.method`, thanks to ruby's awesome object/class system. You just have to attach the callbacks to the singleton class of the object (because that's where the "class side" methods are defined).
+
+Take a look:
+
+```ruby
+module M
+  def self.magic
+    puts 'magic'
+  end
+end
+
+M.singleton_class.extend AfterDo
+M.singleton_class.after :magic do puts 'after_do is pure magic' end
+
+M.magic
+# Output is:
+magic
+after_do is pure magic
+```
+
 ### Usage from within a class
 
-If you got some repetitive tasks, that needs to be done after/before a lot of methods in a class then you can also use after_do for this. This works a bit like `before_action`/`after_action` which you might know from Ruby on Rails.
+If you got some repetitive tasks, that need to be done after/before a lot of methods in a class then you can also use after_do for this. This works a bit like `before_action`/`after_action` (or *_filter in the Rails 3 lingo) which you might know from Ruby on Rails.
 
 E.g. like this:
 
@@ -193,21 +222,6 @@ end
 
 Check out the [within class sample](https://github.com/PragTob/after_do/blob/master/samples/within_class.rb) for a more complete example.
 
-### Working with modules
-
-after_do works with modules just like it works with classes from version 0.3.0 onwards. E.g. you can just do:
-
-```ruby
-class MyClass
-  include MyModule
-  # ....
-end 
-
-MyModule.extend AfterDo
-MyModule.after :some_method do cool_stuff end
-
-MyClass.new.some_method # triggers callback
-```
 
 ### Removing callbacks
 
@@ -217,7 +231,7 @@ You can remove all callbacks you added to a class by doing:
 MyClass.remove_all_callbacks
 ```
 
-Note that this not remove callbacks defined in super classes.
+Note that this not remove callbacks defined in super/sub classes.
 
 ### Errors
 
@@ -225,6 +239,19 @@ There are some custom errors that after_do throws. When you try to add a callbac
 
 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.
 
+### How does it work?
+
+When you attach a callback to a method with after_do 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`.
+
 
 ## Is there a before method?
 
@@ -236,12 +263,11 @@ MyClass.before :a_method do so_much end
 
 Check out the [before sample](https://github.com/PragTob/after_do/blob/master/samples/before.rb).
 
-
 ### Method granularity
 
-after_do 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.
+after_do 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. if 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.
+I sometimes do this for evaluating a 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?
 

data/lib/after_do.rb

@@ -80,7 +80,7 @@ module AfterDo
   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"
+    raise NonExistingMethodError, "There is no method #{method} on #{self} to attach a block to with after_do"
   end
 
   def _after_do_aliased_name(symbol)
@@ -110,9 +110,9 @@ module AfterDo
 
   def _after_do_execute_callback(block, method, object, *args)
     begin
-      block.call *args, object
+      block.call(*args, object)
     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")}"
+      raise CallbackError, "A #{error.class}: #{error.message} was raised during an after_do callback block for method '#{method}' on the instance #{self.inspect} with the following arguments: #{args.join(', ')} defined in the file #{block.source_location[0]} in line #{block.source_location[1]}. This is the backtrace of the #{error.class}: \n #{error.backtrace.join("\n")}"
     end
   end
 end

data/lib/after_do/version.rb

@@ -1,4 +1,4 @@
 module AfterDo
   # ::nodoc::
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/samples/singleton.rb

@@ -0,0 +1,13 @@
+require 'after_do'
+
+module M
+  def self.magic
+    puts 'magic'
+  end
+end
+
+M.singleton_class.extend AfterDo
+M.singleton_class.after :magic do puts 'after_do is pure magic' end
+
+M.magic
+M.magic

data/spec/after_do_spec.rb

@@ -125,11 +125,11 @@ describe AfterDo do
         end
 
         it 'mentions the error raised' do
-          expect_call_back_error /StandardError/
+          expect_call_back_error(/StandardError/)
         end
 
         it 'mentions the method called' do
-          expect_call_back_error /zero/
+          expect_call_back_error(/zero/)
         end
 
         it 'mentions the file the error was raised in' do
@@ -137,7 +137,7 @@ describe AfterDo do
         end
 
         it 'mentions the original error message' do
-          expect_call_back_error /silly message/
+          expect_call_back_error(/silly message/)
         end
       end
     end
@@ -363,6 +363,28 @@ describe AfterDo do
 
       end
     end
+
+    describe 'module/class/singleton methods' do
+      def singleton_module
+        Module.new do
+          def self.my_singleton_method
+            'singleton_method'
+          end
+        end
+      end
+
+      it 'works when you use the singleton_class' do
+        my_module = singleton_module
+        my_module.singleton_class.extend AfterDo
+        my_module.singleton_class.send callback_adder, :my_singleton_method do
+          mockie.call
+        end
+        my_module.my_singleton_method
+        expect(mockie).to have_received(:call)
+      end
+
+    end
+
   end
 
   it_behaves_like 'calling callbacks', :after
@@ -392,4 +414,4 @@ describe AfterDo do
       dummy_instance.zero
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: after_do
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Tobias Pfeiffer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-19 00:00:00.000000000 Z
+date: 2014-03-27 00:00:00.000000000 Z
 dependencies: []
 description: after_do is a gem that let's you execute a block of your choice after
   or before a specific method is called on a class. This is inspired by Aspect Oriented
@@ -19,10 +19,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .ruby-gemset
-- .ruby-version
-- .travis.yml
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -36,6 +36,7 @@ files:
 - samples/error_in_callback.rb
 - samples/getting_a_hold.rb
 - samples/inheritance.rb
+- samples/singleton.rb
 - samples/with_module.rb
 - samples/within_class.rb
 - spec/after_do_spec.rb
@@ -50,17 +51,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: after_do allows you to add simple after/before hooks to methods