after_do 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef369cfcfc9f7d0df1898cb7a19063c54d8197ab
-  data.tar.gz: 5e9cb593b171bdb4847f92aaa6ab8bf12baa3186
+  metadata.gz: 5cfdaaaac12918f8718cd7a32b92cd9c5efc3afe
+  data.tar.gz: ab0e670c82a920ba41e7e5929cb25cc5d56a214b
 SHA512:
-  metadata.gz: 8d27b6cd8f09cad52b0b721c247c598c18178631133b92f730dcaa8b497acbf78a49d5130f9c48cc79528557a4ee0fb3b222b1783461ba26d030d43bff2b2088
-  data.tar.gz: 7af1a95ded2526a59b80d8bf7059df8906844d64ec9755c831170e5dee3e86e62040d08b4586e01381678449563d1a0579807fce67c722fcd81919d3a479ed3f
+  metadata.gz: f8be211216e9f15df0992184aee7159d4c03dc01d1ab8b0c97c823c6a9d64fb885856027286254d8f7d757090eb615489180d9557eb659afdc239fffe3e30ae2
+  data.tar.gz: 1659730491ed28c4445d88629aee0e15e5da21871dca4425e0ae8b4a457e0faff28da45b4a953d4846b8183c56c23ac0c5a9c2905c471d0517c4a2499335e352

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.1
+ruby-2.3.0

data/.travis.yml

@@ -1,8 +1,18 @@
 language: ruby
 rvm:
-  - rbx-2.2.1
-  - jruby-19mode
+  - jruby
   - 1.9.3
   - 2.0
   - 2.1
+  - 2.2
+  - 2.3.0
+  - jruby-9.0.5.0
+  - jruby-head
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+sudo: false
+cache: bundler
+before_script:
+  - "bundle update"
 script: bundle exec rspec spec

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 0.4.0 (March 25th, 2015)
+
+* Hand new arguments to callbacks, namely method name and return value (for after). New Order of block arguments for before is: `arguments, method_name, object`, for after it is: `arguments, method_name, return_value, object`. To migrate to this version you need to change blocks that either use `*args` and then access `args` or calls that do `arg_1, arg_2, object` as the third argument is now the method name. You can change them to `arg_1, arg_2, *, object`.
+* Dropped explicit rubinius support, it should work but dropped testing. If you need it please get in touch.
+
+## 0.3.1 (March 27th, 2014)
+
+* improve error reporting
+* run warning free with -w
+
+## 0.3.0 (January 19th, 2014)
+
+* Work properly with inheritance (callbacks are just called if `super` is really invoked)
+* Work properly with modules (callbacks on module methods are executed when the methods are called)

data/Gemfile

@@ -1,13 +1,8 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in after_do.gemspec
 gemspec
 
-gem 'rubysl', platform: :rbx
-gem 'rubinius-coverage', platform: :rbx
-gem 'json', platform: :rbx
-
-gem 'bundler', '~> 1.3'
+gem 'bundler'
 gem 'rake'
 gem 'rspec'
 gem 'guard-rspec'

data/README.md

@@ -6,6 +6,8 @@ If the class extends `AfterDo` you can simply do this by
 
 ```
 MyClass.after :some_method do whatever_you_want end
+# you can also do before
+MyClass.before :a_method do so_much end
 ```
 
 Some facts about after_do:
@@ -36,7 +38,7 @@ 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'
@@ -79,7 +81,7 @@ dog2.bark
 # I just heard a dog bark!
 ```
 
-### Getting a hold of the method arguments and the object
+### Getting a hold of the method arguments, the object and more!
 
 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.
 
@@ -89,19 +91,47 @@ So if you have a method that takes two arguments you can get those like this:
 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:
+The method name is passed in as the third argument:
 
 ```ruby
-MyClass.after :two_arg_method do |*, obj| fancy_stuff(obj) end
+MyClass.before :two_arg_method do |argument_one, argument_2, method_name|
+  something
+end
+```
+
+The method name is passed for convenience if you do logging for instance. If you start doing `if` or `case` on the method name, rather think about if you should use different callbacks for the different methods.
+
+Another argument that is passed in, but only for `after` is the return value of the method so you can do:
+
+```ruby
+MyClass.after :two_arg_method do |arg1, arg2, name, return_value|
+  report return_value
+end
+```
+
+The object itself is passed in as the last block argument finally so all arguments together are:
+
+```ruby
+MyClass.after :method do |arg1, arg2, name, return_value, object|
+  magic
+end
+
+# remember before doesn't have the return value
+MyClass.before :method do |arg1, arg2, name, object|
+  other_magic
+end
 ```
 
-Of course you can get a hold of the method arguments and the object:
+Why this order of arguments? Well at first there are the arguments related to the method itself (arguments, name and optional return value) and then there is the object.
+
+Of course you can just grab the object, if you're not interested in all the method related data, by using the splat operator to _soak up_ all the other arguments:
 
 ```ruby
-MyClass.after :two_arg_method do |arg1, arg2, obj| something(arg1, arg2, obj) end
+MyClass.after :two_arg_method do |*, obj| fancy_stuff(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 :-)
+
+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 and can leave them out :-)
 
 Check out the [getting a hold sample](https://github.com/PragTob/after_do/blob/master/samples/getting_a_hold.rb) for more.
 
@@ -174,7 +204,7 @@ after_do works with modules just like it works with classes from version 0.3.0 o
 class MyClass
   include MyModule
   # ....
-end 
+end
 
 MyModule.extend AfterDo
 MyModule.after :some_method do cool_stuff end
@@ -252,17 +282,6 @@ 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?
-
-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.
-
-```ruby
-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. 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.
@@ -288,7 +307,9 @@ A use case I feel this is particularly made for is redrawing. That's what we use
 
 ## 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, 2.1, 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 :-)
+Thanks to the awesome [travis CI](https://travis-ci.org/) the specs are run with CRuby 1.9.3, 2.0, 2.1, 2.2, 2.3 and the latest JRuby releases. It _should_ work with rubinius, but some problems lead me to remove it from the build matrix.
+
+So in short, this should work with all of them and is aimed at doing so :-)
 
 ## Contributing
 

data/lib/after_do.rb

@@ -1,5 +1,5 @@
-# The after_do library to add callbacks to methods in Ruby. Before using this
-# with any class, that class has to extend the AfterDo module first e.g.
+# The after_do library adds callbacks to methods in Ruby. Before using this
+# with any class, said class has to extend the AfterDo module first e.g.
 #    MyClass.extend AfterDo
 #    MyClass.after :some_method do awesome_stuff end
 #
@@ -12,7 +12,7 @@ module AfterDo
   class NonExistingMethodError < StandardError ; end
 
   # Raised when an error occurs in one of the callbacks of a method. Provides
-  # additional information as to for which method and where the block was
+  # additional information such as which method and where the block was
   # defined.
   class CallbackError < StandardError ; end
 
@@ -21,18 +21,18 @@ module AfterDo
   #    MyClass.after :some_method do awesome_stuff end
   # It can only take a list of methods after which a block should be executed:
   #    MyClass.after :method1, :method2, :method3 do puts 'jay!' end
-  # The list might also be an Array.
+  # The list can also be an Array.
   def after(*methods, &block)
     _after_do_define_callback(:after, methods, block)
   end
 
-  # This method works much like .after - just that the blocks are executed
+  # This method works much like .after - except blocks are executed
   # before the method is called.
   def before(*methods, &block)
     _after_do_define_callback(:before, methods, block)
   end
 
-  # Removes all callbacks attach to methods in this class.
+  # Removes all callbacks attached to methods in the module.
   def remove_all_callbacks
     @_after_do_callbacks = _after_do_basic_hash
   end
@@ -40,7 +40,7 @@ module AfterDo
   private
   def _after_do_define_callback(type, methods, block)
     @_after_do_callbacks ||= _after_do_basic_hash
-    methods = methods.flatten #in case someone used an Array
+    methods = 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)
@@ -60,17 +60,17 @@ module AfterDo
   end
 
   def _after_do_add_callback_to_method(type, method, block)
-    _after_do_redefine_method(method) unless _after_do_already_redefined?(method)
+    alias_name = _after_do_aliased_name method
+    _after_do_redefine(method, alias_name) unless _after_do_redefined?(alias_name)
     @_after_do_callbacks[type][method] << block
   end
 
-  def _after_do_already_redefined?(method)
-    private_instance_methods(false).include? _after_do_aliased_name(method)
+  def _after_do_redefined?(alias_name)
+    private_instance_methods(false).include? alias_name
   end
 
-  def _after_do_redefine_method(method)
+  def _after_do_redefine(method, alias_name)
     _after_do_raise_no_method_error(method) unless _after_do_defined?(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
@@ -95,24 +95,32 @@ module AfterDo
   def _after_do_redefine_method_with_callback(method, alias_name)
     callback_klazz = self
     define_method method do |*args|
-      callback_klazz.send(:_after_do_execute_callbacks, :before, method, self, *args)
+      callback_klazz.send(:_after_do_execute_before_callbacks, method, self, *args)
       return_value = send(alias_name, *args)
-      callback_klazz.send(:_after_do_execute_callbacks, :after, method, self, *args)
+      callback_klazz.send(:_after_do_execute_after_callbacks, method, self, *args, return_value)
       return_value
     end
   end
 
-  def _after_do_execute_callbacks(type, method, object, *args)
-    @_after_do_callbacks[type][method].each do |block|
-      _after_do_execute_callback(block, method, object, *args)
+  def _after_do_execute_before_callbacks(method, object, *args)
+    _after_do_each_callback_wrapped(:before, method) do |callback|
+      callback.call(*args, method, object)
     end
   end
 
-  def _after_do_execute_callback(block, method, object, *args)
-    begin
-      block.call(*args, object)
-    rescue Exception => error
-      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")}"
+  def _after_do_execute_after_callbacks(method, object, *args, return_value)
+    _after_do_each_callback_wrapped(:after, method) do |callback|
+      callback.call(*args, method, return_value, object)
+    end
+  end
+
+  def _after_do_each_callback_wrapped(type, method)
+    @_after_do_callbacks[type][method].each do |block|
+      begin
+        yield block
+      rescue Exception => error
+        raise CallbackError, "#{error.class}: #{error.message} raised during an after_do callback block for method '#{method}' on the instance #{self.inspect} defined in the file #{block.source_location[0]} in line #{block.source_location[1]}.\n This is the backtrace of the original error: \n #{error.backtrace.join("\n")}"
+      end
     end
   end
 end

data/lib/after_do/version.rb

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

data/samples/getting_a_hold.rb

@@ -2,32 +2,55 @@ require 'after_do'
 
 class Example
   def zero
-    # ...
+    0
   end
 
   def two(a, b)
-    # ...
+    a + b
   end
 
   def value
-    'some 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
+
+# If the callback method takes no arguments then the first argument passed to
+# the block with will the method name, then the return value and finally the object itself
+Example.after :zero do |_name, _return, obj| puts obj.value end
+
+# The method arguments are passed to the callback as well:
+Example.after :two do |first, second| puts "#{first} #{second}" end
+
+# Now alltogether:
+Example.after :two do |a, b, name, value, obj|
+  puts "after: #{a} #{b} #{name} #{value} #{obj.value}"
+end
+
+# Remember before can't get a return value as at that point the method hasn't
+# beene executed:
+Example.before :two do |a, b, name, obj|
+  puts "before: #{a} #{b} #{name} #{obj.value}"
+end
+
+# You can also use the * to soak up all the method arguments and get
+# straight to the instance:
+Example.after :two do |*args, _name, _return, obj|
+  puts "args passed to callback: #{args.join(', ')}"
+  puts 'just ' +  obj.value
+end
 
 e = Example.new
 e.zero
-e.two 'one', 'two'
+e.two 1, 2
 # prints:
 # Hello!
 # some value
-# one two
-# one two some value
-# just some value
+# before: 1 2 two some_value
+# 1 2
+# after: 1 2 two 3 some_value
+# args passed to callback: 1, 2
+# just some value

data/samples/singleton.rb

@@ -10,4 +10,10 @@ M.singleton_class.extend AfterDo
 M.singleton_class.after :magic do puts 'after_do is pure magic' end
 
 M.magic
-M.magic
+M.magic
+
+# prints:
+# magic
+# after_do is pure magic
+# magic
+# after_do is pure magic

data/samples/with_module.rb

@@ -17,7 +17,15 @@ class C
   include M
 
   def method
-    puts 'Overwritten method'
+    puts 'Overridden method'
+  end
+end
+
+class D
+  prepend M
+
+  def method
+    puts 'Wanna be Overriden method'
   end
 end
 
@@ -26,9 +34,15 @@ M.after :method do puts 'method called' end
 
 A.new.method
 B.new.method
-C.new.method # won't call callback since the implementation was overriden
+
+# won't call callback since the implementation was overriden
+C.new.method
+
+# will call callback since the module extending AfterDo was prepended
+D.new.method
 
 # Output is:
 # method called
 # method called
-# Overridden method
+# Overridden method
+# method called

data/spec/after_do_spec.rb

@@ -21,7 +21,7 @@ describe AfterDo do
       end
 
       def two(param1, param2)
-        param2
+        param1 + param2
       end
     end
   end
@@ -117,7 +117,7 @@ describe AfterDo do
         end
 
         before :each do
-          @dummy_class.send callback_adder,  :zero do raise StandardError, 'silly message' end
+          @dummy_class.send callback_adder, :zero do raise StandardError, 'silly message' end
         end
 
         it 'raises a CallbackError' do
@@ -149,12 +149,12 @@ describe AfterDo do
       end
 
       it 'can handle methods with a parameter' do
-        @dummy_class.send callback_adder,  :one do mockie.call_method end
+        @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_class.send callback_adder, :two do mockie.call_method end
         dummy_instance.two 5, 8
       end
     end
@@ -162,13 +162,13 @@ describe AfterDo do
     describe 'with parameters for the given block' do
       it 'can handle one block parameter' do
         expect(mockie).to receive(:call_method).with(5)
-        @dummy_class.send callback_adder,  :one do |i| mockie.call_method i end
+        @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
         expect(mockie).to receive(:call_method).with(5, 8)
-        @dummy_class.send callback_adder,  :two do |i, j| mockie.call_method i, j end
+        @dummy_class.send callback_adder, :two do |i, j| mockie.call_method i, j end
         dummy_instance.two 5, 8
       end
     end
@@ -182,7 +182,7 @@ describe AfterDo do
 
       it 'can take multiple method names as arguments' do
         expect(mockie).to receive(:call_method).exactly(3).times
-        @dummy_class.send callback_adder,  :zero, :one, :two do
+        @dummy_class.send callback_adder, :zero, :one, :two do
           mockie.call_method
         end
         call_all_3_methods
@@ -190,7 +190,7 @@ describe AfterDo do
 
       it 'can get the methods as an Array' do
         expect(mockie).to receive(:call_method).exactly(3).times
-        @dummy_class.send callback_adder,  [:zero, :one, :two] do
+        @dummy_class.send callback_adder, [:zero, :one, :two] do
           mockie.call_method
         end
         call_all_3_methods
@@ -208,7 +208,7 @@ describe AfterDo do
     describe 'it can get a hold of self, if needbe' do
       it 'works for a method without arguments' do
         expect(mockie).to receive(:call_method).with(dummy_instance)
-        @dummy_class.send callback_adder,  :zero do |object|
+        @dummy_class.send callback_adder, :zero do |*_things, object|
           mockie.call_method(object)
         end
         dummy_instance.zero
@@ -216,13 +216,39 @@ describe AfterDo do
 
       it 'works for a method with 2 arguments' do
         expect(mockie).to receive(:call_method).with(1, 2, dummy_instance)
-        @dummy_class.send callback_adder, :two do |first, second, object|
+        @dummy_class.send callback_adder, :two do |first, second, *_things, object|
           mockie.call_method(first, second, object)
         end
         dummy_instance.two 1, 2
       end
     end
 
+    describe 'it can get a hold of the method name, if needbe' do
+      it 'works for a method without arguments' do
+        expect(mockie).to receive(:call_method).with(:zero)
+        @dummy_class.send callback_adder, :zero do |method_name|
+          mockie.call_method(method_name)
+        end
+        dummy_instance.zero
+      end
+
+      it 'works for a method with arguments' do
+        expect(mockie).to receive(:call_method).with(1, 2, :two)
+        @dummy_class.send callback_adder, :two do |arg1, arg2, method_name|
+          mockie.call_method(arg1, arg2, method_name)
+        end
+        dummy_instance.two(1, 2)
+      end
+
+      it 'can also pass along the object' do
+        expect(mockie).to receive(:call_method).with(1, 2, :two, dummy_instance)
+        @dummy_class.send callback_adder, :two do |arg1, arg2, method_name, *, inst|
+          mockie.call_method(arg1, arg2, method_name, inst)
+        end
+        dummy_instance.two(1, 2)
+      end
+    end
+
     describe 'inheritance' do
       let(:inherited_instance) {@inherited_class.new}
 
@@ -414,4 +440,22 @@ describe AfterDo do
       dummy_instance.zero
     end
   end
+
+  describe 'difference between before and after' do
+    it 'after also has access to the return value' do
+      expect(mockie).to receive(:call).with(10, 20, dummy_instance, :two, 30)
+      @dummy_class.after :two do |*args, name, value, inst|
+        mockie.call(args.first, args.last, inst, name, value)
+      end
+      dummy_instance.two 10, 20
+    end
+
+    it 'before can not access to the return value' do
+      expect(mockie).to receive(:call).with(10, 20, dummy_instance, :two)
+      @dummy_class.before :two do |*args, name, inst|
+        mockie.call(args.first, args.last, inst, name)
+      end
+      dummy_instance.two 10, 20
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,7 @@
 require 'simplecov'
 require 'coveralls'
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  Coveralls::SimpleCov::Formatter,
-  SimpleCov::Formatter::HTMLFormatter
-]
+SimpleCov.formatters = [Coveralls::SimpleCov::Formatter,
+                        SimpleCov::Formatter::HTMLFormatter]
 
 SimpleCov.start do
   add_filter '/spec/'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: after_do
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Tobias Pfeiffer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2016-03-25 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
@@ -23,6 +23,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -61,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: after_do allows you to add simple after/before hooks to methods