big_spoon 0.0.1 → 0.1.0

data/CHANGES.md

@@ -1,4 +1,9 @@
 # CHANGELOG
+## 0.1.1
+### :if, :unless, and tested in production!
+- :if => :method and :unless => lambda { false } are now supported.
+- That, or any variation of those two you can imagine.
+
 ## 0.0.1
 ### Basic functionality
 - Hooks / callbacks are working BEFORE OR AFTER a method gets defined

data/README.md

@@ -1,58 +1,116 @@
 # Big Spoon
 Like the big spoon, **Big Spoon** wraps around your own methods.
 It adds before and after callbacks to ANY method in any Ruby class.
+Basically, now you can add hooks and/or callback to **any** Ruby method without fear of reprisals.
 
 There were those who wanted to call it "sandwich," but they were killed.
 
-**Big Spoon** adds _hooks_ around ANY method. It can do this before
-or after the methods are defined, making it awesome for fun stuff like adding extra hooks around events at the top of
-a class definition without having to worry about when the method gets defined.
+## Basic Usage
 
-I think I'm going to import it into all of my libraries to avoid alias\_method_chaining anything ever again.
+Use **Big Spoon** like you would any other callbacks! Of course there's, like, at least three ways to do that. So **Big Spoon** supports all of em. All
+three let you define before- and after-methods or blocks to any method your class could, like, ever call. The safest is block form:
 
-Anyway, here's how it works for now, DON'T use it cause I haven't tested it with shit:
-
-## Usage
+```ruby
+class User
+  hooks do
+    before :get_your_hands_off_of_my_woman, :listen_to_the_darkness
+    after :get_your_hands_off_of_my_woman { listen_to_moar_darkness! }
+  end
 
-Let's say, for example, you want to reset an instance variable in a model when it gets reloaded.
+  def get_your_hands_off_of_my_woman
+    puts "Get your hands off of my woman, motherf*cker!"
+  end
 
-For shits and giggles and real-world-clarity, I'll use an ActiveRecord model but this could be
-anything that knows about `reload`.
+  protected
+  def listen_to_the_darkness!
+    `osascript "tell iTunes to play some awesome"`
+  end
 
-```
-class User < ActiveRecord::Base
-  def name
-    @name ||= "#{first_name} #{last_name}"
+  def listen_to_moar_darkness
+    `osascript "tell iTuens to continue not to suck after that last rad song"`
   end
 end
 ```
 
-So now, when you do something like this:
+This is designed not to conflict with Rails callbacks and their siblings. **But if'n
+you're a real scofflaw (_and you f*cking should be!_), you can just do it normal-like:**
 
-```
-user = User.new(:first_name => "Flip", :last_name => "Sasser")
-user.name #=> "Flip Sasser"
-user.first_name = "Elizabeth"
-user.name #=> "Flip Sasser"
-# OH NOE MY INSTANCE VARIABLE GOT CACHED LIKE IT SHOULD
-user.reload.name #=> "Flip Sasser"
-# OH NOE RELOAD DOESN'T RESET INSTANCE VARIABLES
-```
+```ruby
+class User
+  before_believe_in_a_thing_called_love :listen_to_the_rhythm_of_my_heart
+
+  def believe_in_a_thing_called_love
+    puts "We'll be rockin til the sun goes down!"
+  end
+
+  def listen_to_the_rhythm_of_my_heart
+    listen("127.0.0.1") do
+      match /(lub|dub)/ do
+        puts "Edgar Allan F*cking Poe?!"
+      end
+    end
+  end
+````
+
+So. Add hooks. To any Ruby method. That's pretty damn awesome, where I come form. I SAID "FORM," son!
+
+But, as they say, "love is only a feeling." So spoon like there's no tomorrow.
+
+## But there's (conditionally) more!
+
+Because ActiveModel callbacks are just so damn delightful, I've added some fun conditional sugar to match their wonderful. So g'head and add some `:if` conditions to your callbacks:
+
+```ruby
+class User
+  before :love_on_the_rocks, :add_ice, :if => :no_ice?
 
-But what if you could hook into `ActiveRecord::Base#reload`?
+  def love_on_the_rocks
+    puts "Loo-OOOVE ON THE ROCKS! YOU'D DO ANYTHING FOR A QUIET LIFE!"
+  end
+
+  def no_ice?
+    Ice.empty?
+  end
 
+  protected
+  def add_ice
+    Ice.create!
+  end
+end
 ```
-class User < ActiveRecord::Base
-  hooks do
-    before_reload { @name = nil }
+
+Conditional callbacks also support `:unless`, just like their ActiveModel ancestors. Or should I say "inspiritors?" Is that word? Shut up, of course it is. Anyway:
+
+```ruby
+class User
+  before :love_on_the_rocks, :add_ice, :unless => :not_in_tys_mazada?
+
+  def not_in_tys_mazada?
+    !((mazda = User.find_by_slug("ty").car) && mazda.has_rad_bass?)
   end
 
-  def name
-    @name ||= "#{first_name} #{last_name}"
+  protected
+  def add_ice
+    Ice.create!
   end
 end
 ```
 
-Now you can reset the instance variable. Neat, right? Obviously this is way more awesome way more places but that's the long and short of it.
+And to recap! Just as  with the believing-in-things-called-love example, both could be re-written as
+
+```ruby
+before_love_on_the_rocks :add_ice, :if => :no_ice?
+```
+
+and
+
+```ruby
+before_love_on_the_rocks :add_ice, :unless => :not_in_tys_mazda?
+```
+
+respectively.
+
+HAPPY **CALLING-OF-THE-BACK**, FRIENDS!
+
 
 Copyright © 2012 Delightful Widgets Inc. No warranty so don't sue me or my company THANKS!

data/Rakefile

@@ -9,7 +9,7 @@ begin
       BigSpoon will add a hooks method to every class. Call that method with a block and add all kinds of fun hooks before and after your methods.
     }
     gemspec.email = "flip@x451.com"
-    gemspec.homepage = "http://github.com/Plinq/big_spoon"
+    gemspec.homepage = "https://github.com/flipsasser/big_spoon"
     gemspec.authors = ["Flip Sasser"]
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/big_spoon.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "big_spoon"
-  s.version = "0.0.1"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Flip Sasser"]
@@ -32,7 +32,7 @@ Gem::Specification.new do |s|
     "spec/lib/big_spoon_spec.rb",
     "spec/spec_helper.rb"
   ]
-  s.homepage = "http://github.com/Plinq/big_spoon"
+  s.homepage = "https://github.com/flipsasser/big_spoon"
   s.require_paths = ["lib"]
   s.rubygems_version = "1.8.24"
   s.summary = "Adds before and after hooks to any method, because that's just how things should be"

data/lib/big_spoon/hook.rb

@@ -14,13 +14,13 @@ module BigSpoon
     attr_accessor :klass
 
     # Define a method to execute after another
-    def after(method_to_hook, method_to_call = nil, &block)
-      hook(:after, method_to_hook, method_to_call, &block)
+    def after(method_to_hook, method_to_call = nil, options = {}, &block)
+      hook(:after, method_to_hook, method_to_call, options, &block)
     end
 
     # Define a method to execute before another
-    def before(method_to_hook, method_to_call = nil, &block)
-      hook(:before, method_to_hook, method_to_call, &block)
+    def before(method_to_hook, method_to_call = nil, options = {}, &block)
+      hook(:before, method_to_hook, method_to_call, options, &block)
     end
 
     # def clear!
@@ -45,14 +45,14 @@ module BigSpoon
       hooked_method = hooked_method(method_to_hook)
       original_method = original_method(method_to_hook)
       line = __LINE__; alias_these_hooks = <<-hooks
-        alias :#{original_method} :#{method_to_hook}
-        def #{hooked_method}(*args)
-          Hook.for(self.class).execute_before(:#{method_to_hook}, self)
-          result = #{original_method}
-          Hook.for(self.class).execute_after(:#{method_to_hook}, self)
-          result
-        end
-        alias :#{method_to_hook} :#{hooked_method}
+      alias :#{original_method} :#{method_to_hook}
+      def #{hooked_method}(*args)
+        Hook.for(self.class).execute_before(:#{method_to_hook}, self)
+        result = #{original_method}
+        Hook.for(self.class).execute_after(:#{method_to_hook}, self)
+        result
+      end
+      alias :#{method_to_hook} :#{hooked_method}
       hooks
       klass.class_eval alias_these_hooks, __FILE__, line.succ
     end
@@ -69,8 +69,8 @@ module BigSpoon
       hooked_method = hooked_method(method_to_hook)
       original_method = original_method(method_to_hook)
       line = __LINE__; alias_these_hooks = <<-hooks
-        alias :#{method_to_hook} #{original_method}
-        remove_method #{hooked_method}
+      alias :#{method_to_hook} #{original_method}
+      remove_method #{hooked_method}
       hooks
       klass.class_eval alias_these_hooks, __FILE__, line.succ
     end
@@ -79,18 +79,35 @@ module BigSpoon
     def execute(before_or_after, method_to_hook, instance)
       methods[method_to_hook] ||= {}
       methods[method_to_hook][before_or_after] ||= []
-      methods[method_to_hook][before_or_after].each do |hook_to_call|
-        case hook_to_call
-        when Proc
-          instance.instance_eval(&hook_to_call)
+      methods[method_to_hook][before_or_after].each do |method_definition|
+        execute_for_reals = if method_definition[:if].is_a?(Proc)
+          instance.instance_eval(&method_definition[:if])
+        elsif method_definition[:if]
+          instance.send(method_definition[:if])
+        elsif method_definition[:unless].is_a?(Proc)
+          !instance.instance_eval(&method_definition[:unless])
+        elsif method_definition[:unless]
+          !instance.send(method_definition[:unless])
         else
-          instance.send(hook_to_call)
+          true
+        end
+        if execute_for_reals
+          case method_definition[:method]
+          when Proc
+            instance.instance_eval(&method_definition[:method])
+          else
+            instance.send(method_definition[:method])
+          end
         end
       end
     end
 
-    def hook(before_or_after, method_to_hook, method_to_call = nil, &block)
+    def hook(before_or_after, method_to_hook, method_to_call = nil, options = {}, &block)
       method_to_hook = method_to_hook.to_sym
+      if method_to_call.is_a? Hash
+        options = method_to_call
+        method_to_call = nil
+      end
       if block_given?
         method_to_call = block
       else
@@ -99,7 +116,10 @@ module BigSpoon
 
       methods[method_to_hook] ||= {}
       methods[method_to_hook][before_or_after] ||= []
-      methods[method_to_hook][before_or_after].push(method_to_call) unless methods[method_to_hook][before_or_after].include?(method_to_call)
+      method_definition = options.merge({:method => method_to_call})
+      methods[method_to_hook][before_or_after].push(method_definition) unless methods[method_to_hook][before_or_after].any? do |other_method_definition|
+        other_method_definition[:method] == method_to_call
+      end
 
       hook!(method_to_hook) if should_hook?(method_to_hook)
     end
@@ -112,8 +132,8 @@ module BigSpoon
       klass.method_defined?(hooked_method(method_to_hook))
     end
 
-	  def hooked_method(method_to_hook)
-	    "_big_spoon_alias_#{method_to_hook}"
+    def hooked_method(method_to_hook)
+      "_big_spoon_alias_#{method_to_hook}"
     end
 
     def method_missing(method_name, *args)
@@ -131,8 +151,8 @@ module BigSpoon
       @methods ||= {}
     end
 
-	  def original_method(method_to_hook)
-	    "_big_spoon_original_#{method_to_hook}"
+    def original_method(method_to_hook)
+      "_big_spoon_original_#{method_to_hook}"
     end
   end
 end

data/lib/big_spoon.rb

@@ -19,6 +19,18 @@ module BigSpoon
       end
       @hooks
     end # `hooks` method
+    
+    private
+    def method_missing(method_name, *args)
+      case method_name.to_s
+      when /^after_(.+)$/
+        hooks.after $1, *args
+      when /^before_(.+)$/
+        hooks.before $1, *args
+      else
+        super
+      end
+    end
   end # `ClassMethods` module
 end # `BigSpoon` module
 

data/spec/lib/big_spoon_spec.rb

@@ -18,20 +18,12 @@ class BigSpoonTest
     true
   end
 
-  def dont_hook
+  def please_dont_hook
     false
   end
 
-  def hook_1
-    :hook_1
-  end
-
-  def hook_2
-    :hook_2
-  end
-
-  def hook_3
-    :hook_3
+  (1..8).each do |index|
+    define_method("hook_#{index}") { "hook_#{index}"}
   end
 end
 
@@ -88,4 +80,40 @@ describe BigSpoon do
     end
     @big_spoon_test.foo!
   end
+
+  it "should let me hook outside of the hooks block" do
+    @big_spoon_test.should_receive(:by_all_means_hook)
+    BigSpoonTest.before_foo! :by_all_means_hook
+    @big_spoon_test.foo!
+  end
+
+  it "should not hook if an :if method returns false" do
+    @big_spoon_test.should_not_receive(:hook_4)
+    BigSpoonTest.before_foo! :hook_4, :if => :please_dont_hook
+    @big_spoon_test.foo!
+  end
+
+  it "SHOULD hook if an :if method returns true" do
+    @big_spoon_test.should_receive(:hook_5)
+    BigSpoonTest.before_foo! :hook_5, :if => :by_all_means_hook
+    @big_spoon_test.foo!
+  end
+
+  it "should not hook if an :unless method returns true" do
+    @big_spoon_test.should_not_receive(:hook_6)
+    BigSpoonTest.before_foo! :hook_6, :unless => :by_all_means_hook
+    @big_spoon_test.foo!
+  end
+
+  it "SHOULD hook if an :unless method returns false" do
+    @big_spoon_test.should_receive(:hook_7)
+    BigSpoonTest.before_foo! :hook_7, :unless => :please_dont_hook
+    @big_spoon_test.foo!
+  end
+
+  it "should meta-program before_* hooks" do
+    @big_spoon_test.should_receive(:hook_8)
+    BigSpoonTest.before_foo! :hook_8
+    @big_spoon_test.foo!
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: big_spoon
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -35,7 +35,7 @@ files:
 - lib/big_spoon/hook.rb
 - spec/lib/big_spoon_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/Plinq/big_spoon
+homepage: https://github.com/flipsasser/big_spoon
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -49,7 +49,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4152067215125062110
+      hash: -3518133336514115333
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: